@0xmonaco/core 0.0.0-develop-20260415185155 → 0.0.0-develop-20260420223958

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
  *
@@ -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/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/trading/api.d.ts

@@ -21,7 +21,7 @@
  * );
  * ```
  */
-import type { BatchCancelOrdersResponse, BatchCreateOrderParams, BatchCreateOrdersResponse, BatchReplaceOrderParams, BatchReplaceOrdersResponse, CancelOrderResponse, CreateOrderResponse, GetOrderResponse, GetPaginatedOrdersParams, GetPaginatedOrdersResponse, OrderSide, ReplaceOrderResponse, TimeInForce, TradingAPI, TradingMode } from "@0xmonaco/types";
+import type { BatchCancelOrdersResponse, BatchCreateOrderParams, BatchCreateOrdersResponse, BatchReplaceOrderParams, BatchReplaceOrdersResponse, CancelConditionalOrderResponse, CancelOrderResponse, CreateConditionalOrderParams, CreateConditionalOrderResponse, CreateOrderResponse, GetOrderResponse, GetPaginatedOrdersParams, GetPaginatedOrdersResponse, ListConditionalOrdersParams, ListConditionalOrdersResponse, OrderSide, PositionSide, ReplaceOrderResponse, TimeInForce, TradingAPI, TradingMode } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
     /**
@@ -79,6 +79,10 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
         useMasterBalance?: boolean;
         expirationDate?: string;
         timeInForce?: TimeInForce;
+        marginAccountId?: string;
+        positionSide?: PositionSide;
+        leverage?: string;
+        reduceOnly?: boolean;
     }): Promise<CreateOrderResponse>;
     /**
      * Places a market order for immediate execution.
@@ -124,6 +128,10 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
     placeMarketOrder(tradingPairId: string, side: OrderSide, quantity: string, options?: {
         tradingMode?: TradingMode;
         slippageTolerance?: number;
+        marginAccountId?: string;
+        positionSide?: PositionSide;
+        leverage?: string;
+        reduceOnly?: boolean;
     }): Promise<CreateOrderResponse>;
     /**
      * Cancels an existing order.
@@ -142,6 +150,9 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      * ```
      */
     cancelOrder(orderId: string): Promise<CancelOrderResponse>;
+    createConditionalOrder(params: CreateConditionalOrderParams): Promise<CreateConditionalOrderResponse>;
+    cancelConditionalOrder(conditionalOrderId: string): Promise<CancelConditionalOrderResponse>;
+    listConditionalOrders(params?: ListConditionalOrdersParams): Promise<ListConditionalOrdersResponse>;
     /**
      * Batch cancels specific orders by their IDs.
      *

package/dist/api/trading/api.js

@@ -21,8 +21,9 @@
  * );
  * ```
  */
-import { BatchCreateOrdersSchema, BatchReplaceOrdersSchema, CancelOrderSchema, GetPaginatedOrdersSchema, PlaceLimitOrderSchema, PlaceMarketOrderSchema, ReplaceOrderSchema, validate, } from "@0xmonaco/types";
+import { BatchCreateOrdersSchema, BatchReplaceOrdersSchema, CancelConditionalOrderSchema, CancelOrderSchema, CreateConditionalOrderSchema, GetPaginatedOrdersSchema, ListConditionalOrdersSchema, PlaceLimitOrderSchema, PlaceMarketOrderSchema, ReplaceOrderSchema, validate, } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
+import { perpRoutes } from "../perp";
 export class TradingAPIImpl extends BaseAPI {
     /**
      * Places a limit order on the order book.
@@ -93,8 +94,12 @@ export class TradingAPIImpl extends BaseAPI {
             use_master_balance: options?.useMasterBalance,
             expiration_date: options?.expirationDate,
             time_in_force: options?.timeInForce,
+            margin_account_id: options?.marginAccountId,
+            position_side: options?.positionSide,
+            leverage: options?.leverage,
+            reduce_only: options?.reduceOnly,
         };
-        return await this.makeAuthenticatedRequest("/api/v1/orders", {
+        return await this.makeAuthenticatedRequest(perpRoutes.orders.create(), {
             method: "POST",
             body: JSON.stringify(requestBody),
         });
@@ -156,8 +161,12 @@ export class TradingAPIImpl extends BaseAPI {
             price: null, // Market orders don't need price
             quantity,
             trading_mode: options?.tradingMode || "SPOT",
+            margin_account_id: options?.marginAccountId,
+            position_side: options?.positionSide,
+            leverage: options?.leverage,
+            reduce_only: options?.reduceOnly,
         };
-        return await this.makeAuthenticatedRequest("/api/v1/orders", {
+        return await this.makeAuthenticatedRequest(perpRoutes.orders.create(), {
             method: "POST",
             body: JSON.stringify(requestBody),
         });
@@ -184,11 +193,53 @@ export class TradingAPIImpl extends BaseAPI {
         const requestBody = {
             order_id: orderId,
         };
-        return await this.makeAuthenticatedRequest("/api/v1/orders/cancel", {
+        return await this.makeAuthenticatedRequest(perpRoutes.orders.cancel(), {
             method: "POST",
             body: JSON.stringify(requestBody),
         });
     }
+    async createConditionalOrder(params) {
+        validate(CreateConditionalOrderSchema, params);
+        const requestBody = {
+            trading_pair_id: params.tradingPairId,
+            margin_account_id: params.marginAccountId,
+            condition_type: params.conditionType,
+            trigger_price: params.triggerPrice,
+            trigger_source: params.triggerSource ?? "MARK_PRICE",
+            side: params.side,
+            position_side: params.positionSide,
+            order_type: params.orderType,
+            limit_price: params.limitPrice,
+            quantity: params.quantity,
+            reduce_only: params.reduceOnly ?? true,
+            time_in_force: params.timeInForce,
+            slippage_tolerance_bps: params.slippageToleranceBps,
+            expires_at: params.expiresAt,
+        };
+        return await this.makeAuthenticatedRequest(perpRoutes.orders.createConditional(), {
+            method: "POST",
+            body: JSON.stringify(requestBody),
+        });
+    }
+    async cancelConditionalOrder(conditionalOrderId) {
+        validate(CancelConditionalOrderSchema, { conditionalOrderId });
+        return await this.makeAuthenticatedRequest(perpRoutes.orders.cancelConditional(conditionalOrderId), {
+            method: "DELETE",
+        });
+    }
+    async listConditionalOrders(params) {
+        if (params) {
+            validate(ListConditionalOrdersSchema, params);
+        }
+        const { page = 1, page_size = 20, margin_account_id, trading_pair_id, state } = params || {};
+        return await this.makeAuthenticatedRequest(perpRoutes.orders.listConditional({
+            page,
+            page_size: Math.min(Math.max(page_size, 1), 100),
+            margin_account_id,
+            trading_pair_id,
+            state,
+        }), { method: "GET" });
+    }
     /**
      * Batch cancels specific orders by their IDs.
      *
@@ -205,7 +256,7 @@ export class TradingAPIImpl extends BaseAPI {
         if (!orderIds || orderIds.length === 0) {
             throw new Error("orderIds is required and must not be empty");
         }
-        return this.makeAuthenticatedRequest("/api/v1/orders/batch-cancel", {
+        return this.makeAuthenticatedRequest(perpRoutes.orders.batchCancel(), {
             method: "POST",
             body: JSON.stringify({ order_ids: orderIds }),
         });
@@ -227,7 +278,7 @@ export class TradingAPIImpl extends BaseAPI {
      * ```
      */
     async batchCancelAll(tradingPairId) {
-        const endpoint = tradingPairId ? `/api/v1/orders/batch-cancel-all/${tradingPairId}` : "/api/v1/orders/batch-cancel-all";
+        const endpoint = tradingPairId ? perpRoutes.orders.batchCancelAllByPair(tradingPairId) : perpRoutes.orders.batchCancelAll();
         return this.makeAuthenticatedRequest(endpoint, {
             method: "POST",
         });
@@ -244,7 +295,7 @@ export class TradingAPIImpl extends BaseAPI {
         if (newOrder.quantity !== undefined) {
             requestBody.quantity = newOrder.quantity;
         }
-        return await this.makeAuthenticatedRequest(`/api/v1/orders/${orderId}`, {
+        return await this.makeAuthenticatedRequest(perpRoutes.orders.replace(orderId), {
             method: "PUT",
             body: JSON.stringify(requestBody),
         });
@@ -293,9 +344,13 @@ export class TradingAPIImpl extends BaseAPI {
                 use_master_balance: order.useMasterBalance,
                 expiration_date: order.expirationDate,
                 time_in_force: order.timeInForce,
+                margin_account_id: order.marginAccountId,
+                position_side: order.positionSide,
+                leverage: order.leverage,
+                reduce_only: order.reduceOnly,
             })),
         };
-        return this.makeAuthenticatedRequest("/api/v1/orders/batch-create", {
+        return this.makeAuthenticatedRequest(perpRoutes.orders.batchCreate(), {
             method: "POST",
             body: JSON.stringify(requestBody),
         });
@@ -335,7 +390,7 @@ export class TradingAPIImpl extends BaseAPI {
                 use_master_balance: order.useMasterBalance,
             })),
         };
-        return this.makeAuthenticatedRequest("/api/v1/orders/batch-replace", {
+        return this.makeAuthenticatedRequest(perpRoutes.orders.batchReplace(), {
             method: "POST",
             body: JSON.stringify(requestBody),
         });
@@ -375,7 +430,7 @@ export class TradingAPIImpl extends BaseAPI {
             validate(GetPaginatedOrdersSchema, params);
         }
         // Set pagination defaults with destructuring and validation
-        const { page = 1, page_size = 10, status, trading_pair_id } = params || {};
+        const { page = 1, page_size = 10, status, trading_pair_id, trading_mode, margin_account_id } = params || {};
         const validPage = page > 0 ? page : 1;
         const validPageSize = page_size > 0 ? page_size : 10;
         const pageSize = Math.min(validPageSize, 100);
@@ -389,6 +444,12 @@ export class TradingAPIImpl extends BaseAPI {
         if (trading_pair_id) {
             searchParams.append("trading_pair_id", trading_pair_id);
         }
+        if (trading_mode) {
+            searchParams.append("trading_mode", trading_mode);
+        }
+        if (margin_account_id) {
+            searchParams.append("margin_account_id", margin_account_id);
+        }
         const endpoint = `/api/v1/orders?${searchParams.toString()}`;
         return await this.makeAuthenticatedRequest(endpoint, {
             method: "GET",
@@ -413,7 +474,7 @@ export class TradingAPIImpl extends BaseAPI {
      * ```
      */
     async getOrder(orderId) {
-        return await this.makeAuthenticatedRequest(`/api/v1/orders/${orderId}`, {
+        return await this.makeAuthenticatedRequest(perpRoutes.orders.get(orderId), {
             method: "GET",
         });
     }

package/dist/api/websocket/types.d.ts

@@ -1,4 +1,4 @@
-import type { Interval, OHLCVEvent, OrderbookEvent, OrderbookQuotationMode, OrderEvent, TradeEvent, TradingMode, UserBalanceEvent, UserMovementEvent, WebSocketStatus } from "@0xmonaco/types";
+import type { ConditionalOrderEvent, Interval, OHLCVEvent, OrderbookEvent, OrderbookQuotationMode, OrderEvent, TradeEvent, TradingMode, UserBalanceEvent, UserMovementEvent, WebSocketStatus } from "@0xmonaco/types";
 export type StatusHandler = (status: WebSocketStatus) => void;
 export type MessageHandler<T> = (data: T) => void;
 export interface MonacoWebSocketOptions {
@@ -36,4 +36,6 @@ export interface MonacoWebSocket {
     userOrders: (handler: MessageHandler<OrderEvent>) => () => void;
     /** Subscribe to user balance events (requires authentication) */
     balances: (handler: MessageHandler<UserBalanceEvent>) => () => void;
+    /** Subscribe to conditional TP/SL lifecycle events (requires authentication) */
+    conditionalOrders: (handler: MessageHandler<ConditionalOrderEvent>, tradingPairId?: string) => () => void;
 }

package/dist/api/websocket/websocket.js

@@ -4,6 +4,100 @@ import { keysToCamelCase } from "./utils";
 const CONNECTION_TIMEOUT = 10000;
 const HEARTBEAT_INTERVAL = 15000;
 const MAX_RECONNECT_DELAY = 30000;
+const CONDITIONAL_ORDER_REASONS = ["created", "cancelled", "triggered", "failed", "oco_cancelled"];
+const CONDITIONAL_ORDER_CONDITION_TYPES = ["STOP_LOSS", "TAKE_PROFIT"];
+const CONDITIONAL_ORDER_TRIGGER_SOURCES = ["MARK_PRICE"];
+const CONDITIONAL_ORDER_STATES = ["ACTIVE", "TRIGGERING", "TRIGGERED", "CANCELLED", "EXPIRED", "FAILED"];
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(source, field) {
+    const value = source[field];
+    if (typeof value !== "string" || value.length === 0) {
+        throw new Error(`Invalid conditional order event: ${field} must be a non-empty string`);
+    }
+    return value;
+}
+function readOptionalString(source, field) {
+    const value = source[field];
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "string") {
+        throw new Error(`Invalid conditional order event: ${field} must be a string`);
+    }
+    return value;
+}
+function readBoolean(source, field) {
+    const value = source[field];
+    if (typeof value !== "boolean") {
+        throw new Error(`Invalid conditional order event: ${field} must be a boolean`);
+    }
+    return value;
+}
+function readOptionalNumber(source, field) {
+    const value = source[field];
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new Error(`Invalid conditional order event: ${field} must be a finite number`);
+    }
+    return value;
+}
+function readEnum(source, field, allowed) {
+    const value = readString(source, field);
+    if (!allowed.includes(value)) {
+        throw new Error(`Invalid conditional order event: ${field} must be one of ${allowed.join(", ")}`);
+    }
+    return value;
+}
+function readOptionalEnum(source, field, allowed) {
+    const value = source[field];
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "string" || !allowed.includes(value)) {
+        throw new Error(`Invalid conditional order event: ${field} must be one of ${allowed.join(", ")}`);
+    }
+    return value;
+}
+function parseConditionalOrderEvent(rawData) {
+    if (!isRecord(rawData)) {
+        throw new Error("Invalid conditional order event: payload must be an object");
+    }
+    if (!isRecord(rawData.data)) {
+        throw new Error("Invalid conditional order event: data must be an object");
+    }
+    const data = keysToCamelCase(rawData.data);
+    return {
+        eventType: readEnum(rawData, "event_type", ["conditional_order_update"]),
+        userId: readString(rawData, "user_id"),
+        data: {
+            conditionalOrderId: readString(data, "conditionalOrderId"),
+            tradingPairId: readString(data, "tradingPairId"),
+            marginAccountId: readString(data, "marginAccountId"),
+            positionId: readOptionalString(data, "positionId"),
+            linkedGroupId: readOptionalString(data, "linkedGroupId"),
+            conditionType: readEnum(data, "conditionType", CONDITIONAL_ORDER_CONDITION_TYPES),
+            triggerSource: readEnum(data, "triggerSource", CONDITIONAL_ORDER_TRIGGER_SOURCES),
+            triggerPrice: readString(data, "triggerPrice"),
+            side: readEnum(data, "side", ["BUY", "SELL"]),
+            positionSide: readEnum(data, "positionSide", ["LONG", "SHORT", "NONE"]),
+            orderType: readEnum(data, "orderType", ["LIMIT", "MARKET"]),
+            limitPrice: readOptionalString(data, "limitPrice"),
+            quantity: readOptionalString(data, "quantity"),
+            slippageToleranceBps: readOptionalNumber(data, "slippageToleranceBps"),
+            reduceOnly: readBoolean(data, "reduceOnly"),
+            timeInForce: readOptionalEnum(data, "timeInForce", ["GTC", "IOC"]),
+            state: readEnum(data, "state", CONDITIONAL_ORDER_STATES),
+            triggeredOrderId: readOptionalString(data, "triggeredOrderId"),
+            triggeredAt: readOptionalString(data, "triggeredAt"),
+            cancelledAt: readOptionalString(data, "cancelledAt"),
+            expiresAt: readOptionalString(data, "expiresAt"),
+            failureReason: readOptionalString(data, "failureReason"),
+            reason: readEnum(data, "reason", CONDITIONAL_ORDER_REASONS),
+            updatedAt: readString(data, "updatedAt"),
+        },
+    };
+}
 /**
  * Create a Monaco WebSocket client
  */
@@ -62,7 +156,11 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
         }
         reconnectAttempts++;
         const delay = Math.min(1000 * 2 ** reconnectAttempts, MAX_RECONNECT_DELAY);
-        reconnectTimer = setTimeout(() => connect(), delay);
+        reconnectTimer = setTimeout(() => {
+            connect().catch((err) => {
+                console.warn("WebSocket: Failed to reconnect:", err);
+            });
+        }, delay);
     };
     const send = (data) => {
         if (ws?.readyState === WebSocket.OPEN) {
@@ -84,7 +182,6 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
                 for (const handler of channelHandlers) {
                     handler(msg.data);
                 }
-                return;
             }
         }
     };
@@ -96,22 +193,33 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
                 return;
             }
             try {
-                ws = new WebSocket(getUrl());
+                const socket = new WebSocket(getUrl());
+                ws = socket;
                 const timeout = setTimeout(() => {
-                    if (ws?.readyState === WebSocket.CONNECTING) {
-                        ws.close();
+                    if (ws !== socket) {
+                        resolve();
+                        return;
+                    }
+                    if (socket.readyState === WebSocket.CONNECTING) {
+                        socket.close(1000, "Connection timeout");
                         reject(new Error("WebSocket connection timeout"));
                     }
                 }, CONNECTION_TIMEOUT);
-                ws.onopen = () => {
+                socket.onopen = () => {
                     clearTimeout(timeout);
+                    if (ws !== socket) {
+                        resolve();
+                        return;
+                    }
                     reconnectAttempts = 0;
                     startHeartbeat();
                     resubscribeAll();
                     options.onStatusChange?.("connected");
                     resolve();
                 };
-                ws.onmessage = (event) => {
+                socket.onmessage = (event) => {
+                    if (ws !== socket)
+                        return;
                     try {
                         const msg = JSON.parse(event.data);
                         // Handle pong silently
@@ -123,8 +231,13 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
                         console.warn("WebSocket: Failed to parse message", err);
                     }
                 };
-                ws.onclose = (event) => {
+                socket.onclose = (event) => {
                     clearTimeout(timeout);
+                    if (ws !== socket) {
+                        resolve();
+                        return;
+                    }
+                    ws = null;
                     stopHeartbeat();
                     options.onStatusChange?.("disconnected");
                     // Reconnect on abnormal close
@@ -132,7 +245,7 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
                         scheduleReconnect();
                     }
                 };
-                ws.onerror = () => clearTimeout(timeout);
+                socket.onerror = () => clearTimeout(timeout);
             }
             catch (err) {
                 options.onStatusChange?.("disconnected");
@@ -393,18 +506,40 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
             }
         });
     };
+    const subscribeConditionalOrders = (handler, tradingPairId) => {
+        if (!handler) {
+            throw new Error("conditionalOrders subscription requires a handler");
+        }
+        if (tradingPairId !== undefined && tradingPairId.length === 0) {
+            throw new Error("conditionalOrders tradingPairId cannot be empty");
+        }
+        const channel = tradingPairId ? `conditional_orders:${tradingPairId}` : "conditional_orders";
+        return subscribe(channel, (rawData) => {
+            try {
+                handler(parseConditionalOrderEvent(rawData));
+            }
+            catch (err) {
+                console.error("WebSocket: Error processing conditional order event", err);
+            }
+        });
+    };
     return {
         connect,
         disconnect,
         isConnected: () => ws?.readyState === WebSocket.OPEN,
         getStatus,
         setToken: (newToken) => {
-            token = newToken;
-            // Reconnect to include token in ws URL
-            if (ws?.readyState === WebSocket.OPEN || ws?.readyState === WebSocket.CONNECTING) {
-                ws.close(1000, "Token updated, reconnecting.");
+            token = newToken || undefined;
+            stopReconnect();
+            const currentSocket = ws;
+            if (currentSocket?.readyState === WebSocket.OPEN ||
+                currentSocket?.readyState === WebSocket.CONNECTING ||
+                currentSocket?.readyState === WebSocket.CLOSING) {
+                currentSocket.close(1000, newToken ? "Token updated, reconnecting." : "Token cleared.");
                 ws = null;
             }
+            if (!newToken)
+                return;
             connect().catch((err) => {
                 console.warn("WebSocket: Failed to reconnect after token update:", err);
             });
@@ -416,5 +551,6 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
         movements: subscribeMovements,
         userOrders: subscribeUserOrders,
         balances: subscribeBalances,
+        conditionalOrders: subscribeConditionalOrders,
     };
 }

package/dist/sdk.d.ts

@@ -1,4 +1,4 @@
-import type { ApplicationsAPI, AuthAPI, AuthState, FeesAPI, MarketAPI, MonacoSDK, Network, ProfileAPI, SDKConfig, TradingAPI, VaultAPI } from "@0xmonaco/types";
+import type { ApplicationsAPI, AuthAPI, AuthState, FeesAPI, MarginAccountsAPI, MarketAPI, MonacoSDK, Network, PositionsAPI, ProfileAPI, SDKConfig, TradingAPI, VaultAPI } from "@0xmonaco/types";
 import { type PublicClient, type TransactionReceipt, type WalletClient } from "viem";
 import { type MonacoWebSocket, OrderbookAPIImpl, TradesAPIImpl } from "./api";
 export declare class MonacoSDKImpl implements MonacoSDK {
@@ -8,6 +8,8 @@ export declare class MonacoSDKImpl implements MonacoSDK {
     vault: VaultAPI;
     trading: TradingAPI;
     market: MarketAPI;
+    marginAccounts: MarginAccountsAPI;
+    positions: PositionsAPI;
     profile: ProfileAPI;
     orderbook: OrderbookAPIImpl;
     trades: TradesAPIImpl;

package/dist/sdk.js

@@ -4,7 +4,9 @@ import { sei, seiTestnet } from "viem/chains";
 import { ApplicationsAPIImpl, createMonacoWebSocket, OrderbookAPIImpl, TradesAPIImpl } from "./api";
 import { AuthAPIImpl } from "./api/auth";
 import { FeesAPIImpl } from "./api/fees";
+import { MarginAccountsAPIImpl } from "./api/margin-accounts";
 import { MarketAPIImpl } from "./api/market";
+import { PositionsAPIImpl } from "./api/positions";
 import { ProfileAPIImpl } from "./api/profile";
 import { TradingAPIImpl } from "./api/trading";
 import { VaultAPIImpl } from "./api/vault";
@@ -17,6 +19,8 @@ export class MonacoSDKImpl {
     vault;
     trading;
     market;
+    marginAccounts;
+    positions;
     profile;
     orderbook;
     trades;
@@ -36,7 +40,11 @@ export class MonacoSDKImpl {
         this.vault.setAccessToken(accessToken);
         this.trading.setAccessToken(accessToken);
         this.market.setAccessToken(accessToken);
+        this.marginAccounts.setAccessToken(accessToken);
+        this.positions.setAccessToken(accessToken);
         this.profile.setAccessToken(accessToken);
+        this.orderbook.setAccessToken(accessToken);
+        this.trades.setAccessToken(accessToken);
         this.ws.setToken(accessToken);
     }
     constructor(cfg) {
@@ -79,6 +87,8 @@ export class MonacoSDKImpl {
         // Instantiate APIs (wallet-dependent APIs will be initialized lazily or error if wallet not set)
         this.applications = new ApplicationsAPIImpl(apiUrl);
         this.market = new MarketAPIImpl(apiUrl);
+        this.marginAccounts = new MarginAccountsAPIImpl(apiUrl);
+        this.positions = new PositionsAPIImpl(apiUrl);
         this.auth = new AuthAPIImpl(this.walletClient, this.chain, apiUrl);
         this.fees = new FeesAPIImpl(apiUrl);
         this.profile = new ProfileAPIImpl(apiUrl);
@@ -179,11 +189,9 @@ export class MonacoSDKImpl {
                 console.warn("Failed to revoke token on logout:", error);
             }
         }
-        // Disconnect WebSocket if connected
-        if (this.ws.isConnected()) {
-            this.ws.disconnect();
-        }
         this.authState = undefined;
+        this.propagateAccessToken("");
+        this.ws.disconnect();
     }
     /**
      * Refresh the access token

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0xmonaco/core",
-	"version": "0.0.0-develop-20260415185155",
+	"version": "0.0.0-develop-20260420223958",
 	"type": "module",
 	"repository": {
 		"type": "git",
@@ -23,8 +23,8 @@
 		"viem": "^2.45.2"
 	},
 	"dependencies": {
-		"@0xmonaco/contracts": "0.0.0-develop-20260415185155",
-		"@0xmonaco/types": "0.0.0-develop-20260415185155",
+		"@0xmonaco/contracts": "0.0.0-develop-20260420223958",
+		"@0xmonaco/types": "0.0.0-develop-20260420223958",
 		"http-status-codes": "^2.3.0"
 	},
 	"devDependencies": {