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

package/dist/hooks/index.d.ts

@@ -4,6 +4,7 @@ export * from "./useMarket";
 export * from "./useMonaco";
 export * from "./useOHLCV";
 export * from "./useOrderbook";
+export * from "./usePositions";
 export * from "./useProfile";
 export * from "./useTokenLifecycle";
 export * from "./useTrade";

package/dist/hooks/index.js

@@ -4,6 +4,7 @@ export * from "./useMarket";
 export * from "./useMonaco";
 export * from "./useOHLCV";
 export * from "./useOrderbook";
+export * from "./usePositions";
 export * from "./useProfile";
 export * from "./useTokenLifecycle";
 export * from "./useTrade";

package/dist/hooks/useMarket/types.d.ts

@@ -1,4 +1,4 @@
-import type { Candlestick, GetCandlesticksParams, GetTradingPairsParams, GetTradingPairsResponse, Interval, MarketMetadata, TradingPair } from "@0xmonaco/types";
+import type { Candlestick, FundingState, GetCandlesticksParams, GetTradingPairsParams, GetTradingPairsResponse, IndexPrice, Interval, ListFundingHistoryParams, ListFundingHistoryResponse, MarketMetadata, MarkPrice, OpenInterest, PerpMarketConfig, PerpMarketSummary, TradingPair } from "@0xmonaco/types";
 export interface UseMarketReturn {
     /** Get all available trading pairs with optional filtering and pagination */
     getPaginatedTradingPairs: (params?: GetTradingPairsParams) => Promise<GetTradingPairsResponse>;
@@ -20,4 +20,11 @@ export interface UseMarketReturn {
     getCandlesticks: (tradingPairId: string, interval: Interval, params?: GetCandlesticksParams) => Promise<Candlestick[]>;
     /** Get comprehensive market metadata including 24h statistics */
     getMarketMetadata: (pairId: 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/hooks/useMarket/useMarket.js

@@ -1,5 +1,9 @@
 import { useCallback } from "react";
 import { useMonacoSDK } from "../useMonaco";
+function requireTradingPairId(tradingPairId) {
+    if (!tradingPairId?.trim())
+        throw new Error("Trading pair ID is required and cannot be empty");
+}
 export const useMarket = () => {
     const { sdk } = useMonacoSDK();
     const getPaginatedTradingPairs = useCallback(async (params) => {
@@ -30,10 +34,59 @@ export const useMarket = () => {
             throw new Error("Pair ID is required and cannot be empty");
         return await sdk.market.getMarketMetadata(pairId);
     }, [sdk]);
+    const getPerpMarketConfig = useCallback(async (tradingPairId) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        requireTradingPairId(tradingPairId);
+        return await sdk.market.getPerpMarketConfig(tradingPairId);
+    }, [sdk]);
+    const getPerpMarketSummary = useCallback(async (tradingPairId) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        requireTradingPairId(tradingPairId);
+        return await sdk.market.getPerpMarketSummary(tradingPairId);
+    }, [sdk]);
+    const getMarkPrice = useCallback(async (tradingPairId) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        requireTradingPairId(tradingPairId);
+        return await sdk.market.getMarkPrice(tradingPairId);
+    }, [sdk]);
+    const getIndexPrice = useCallback(async (tradingPairId) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        requireTradingPairId(tradingPairId);
+        return await sdk.market.getIndexPrice(tradingPairId);
+    }, [sdk]);
+    const getFundingState = useCallback(async (tradingPairId) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        requireTradingPairId(tradingPairId);
+        return await sdk.market.getFundingState(tradingPairId);
+    }, [sdk]);
+    const listFundingHistory = useCallback(async (tradingPairId, params) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        requireTradingPairId(tradingPairId);
+        return await sdk.market.listFundingHistory(tradingPairId, params);
+    }, [sdk]);
+    const getOpenInterest = useCallback(async (tradingPairId) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        requireTradingPairId(tradingPairId);
+        return await sdk.market.getOpenInterest(tradingPairId);
+    }, [sdk]);
     return {
         getPaginatedTradingPairs,
         getTradingPairBySymbol,
         getCandlesticks,
         getMarketMetadata,
+        getPerpMarketConfig,
+        getPerpMarketSummary,
+        getMarkPrice,
+        getIndexPrice,
+        getFundingState,
+        listFundingHistory,
+        getOpenInterest,
     };
 };

package/dist/hooks/usePositions/index.d.ts

@@ -0,0 +1,2 @@
+export type { UsePositionsReturn } from "./types";
+export { usePositions } from "./usePositions";

package/dist/hooks/usePositions/index.js

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

package/dist/hooks/usePositions/types.d.ts

@@ -0,0 +1,11 @@
+import type { AddPositionMarginRequest, AttachPositionTpSlRequest, AttachPositionTpSlResponse, ClosePositionRequest, ClosePositionResponse, GetPositionResponse, ListPositionHistoryParams, ListPositionHistoryResponse, ListPositionsParams, ListPositionsResponse, PositionMarginResponse, PositionRisk, ReducePositionMarginRequest } from "@0xmonaco/types";
+export interface UsePositionsReturn {
+    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/hooks/usePositions/usePositions.d.ts

@@ -0,0 +1,2 @@
+import type { UsePositionsReturn } from "./types";
+export declare const usePositions: () => UsePositionsReturn;

package/dist/hooks/usePositions/usePositions.js

@@ -0,0 +1,65 @@
+import { useCallback } from "react";
+import { useMonacoSDK } from "../useMonaco";
+function requirePositionId(positionId) {
+    if (!positionId?.trim())
+        throw new Error("Position ID is required and cannot be empty");
+}
+export const usePositions = () => {
+    const { sdk } = useMonacoSDK();
+    const listPositions = useCallback(async (params) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        return await sdk.positions.listPositions(params);
+    }, [sdk]);
+    const getPosition = useCallback(async (positionId) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        requirePositionId(positionId);
+        return await sdk.positions.getPosition(positionId);
+    }, [sdk]);
+    const closePosition = useCallback(async (positionId, request) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        requirePositionId(positionId);
+        return await sdk.positions.closePosition(positionId, request);
+    }, [sdk]);
+    const getPositionRisk = useCallback(async (positionId) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        requirePositionId(positionId);
+        return await sdk.positions.getPositionRisk(positionId);
+    }, [sdk]);
+    const addPositionMargin = useCallback(async (positionId, request) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        requirePositionId(positionId);
+        return await sdk.positions.addPositionMargin(positionId, request);
+    }, [sdk]);
+    const reducePositionMargin = useCallback(async (positionId, request) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        requirePositionId(positionId);
+        return await sdk.positions.reducePositionMargin(positionId, request);
+    }, [sdk]);
+    const attachPositionTpSl = useCallback(async (positionId, request) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        requirePositionId(positionId);
+        return await sdk.positions.attachPositionTpSl(positionId, request);
+    }, [sdk]);
+    const listPositionHistory = useCallback(async (params) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        return await sdk.positions.listPositionHistory(params);
+    }, [sdk]);
+    return {
+        listPositions,
+        getPosition,
+        closePosition,
+        getPositionRisk,
+        addPositionMargin,
+        reducePositionMargin,
+        attachPositionTpSl,
+        listPositionHistory,
+    };
+};

package/dist/hooks/useTrade/types.d.ts

@@ -1,4 +1,4 @@
-import type { BatchCancelOrdersResponse, BatchCreateOrderParams, BatchCreateOrdersResponse, BatchReplaceOrderParams, BatchReplaceOrdersResponse, CancelOrderResponse, CreateOrderResponse, GetOrderResponse, GetPaginatedOrdersParams, GetPaginatedOrdersResponse, OrderSide, ReplaceOrderResponse, TimeInForce, 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, TradingMode } from "@0xmonaco/types";
 export interface UseTradeReturn {
     /** Place a limit order */
     placeLimitOrder: (tradingPairId: string, side: OrderSide, quantity: string, price: string, options?: {
@@ -6,14 +6,28 @@ export interface UseTradeReturn {
         useMasterBalance?: boolean;
         expirationDate?: string;
         timeInForce?: TimeInForce;
+        marginAccountId?: string;
+        positionSide?: PositionSide;
+        leverage?: string;
+        reduceOnly?: boolean;
     }) => Promise<CreateOrderResponse>;
     /** Place a market order */
     placeMarketOrder: (tradingPairId: string, side: OrderSide, quantity: string, options?: {
         tradingMode?: TradingMode;
         slippageTolerance?: number;
+        marginAccountId?: string;
+        positionSide?: PositionSide;
+        leverage?: string;
+        reduceOnly?: boolean;
     }) => Promise<CreateOrderResponse>;
     /** Cancel an existing order */
     cancelOrder: (orderId: string) => Promise<CancelOrderResponse>;
+    /** Create a standalone conditional TP/SL order */
+    createConditionalOrder: (params: CreateConditionalOrderParams) => Promise<CreateConditionalOrderResponse>;
+    /** Cancel an active conditional TP/SL order */
+    cancelConditionalOrder: (conditionalOrderId: string) => Promise<CancelConditionalOrderResponse>;
+    /** List conditional TP/SL orders */
+    listConditionalOrders: (params?: ListConditionalOrdersParams) => Promise<ListConditionalOrdersResponse>;
     /** Batch cancel specific orders by their IDs */
     batchCancel: (orderIds: string[]) => Promise<BatchCancelOrdersResponse>;
     /** Cancel all active orders, optionally filtered by trading pair */

package/dist/hooks/useTrade/useTrade.js

@@ -39,6 +39,23 @@ export const useTrade = () => {
             throw new Error("Order ID is required and cannot be empty");
         return await sdk.trading.cancelOrder(orderId);
     }, [sdk]);
+    const createConditionalOrder = useCallback(async (params) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        return await sdk.trading.createConditionalOrder(params);
+    }, [sdk]);
+    const cancelConditionalOrder = useCallback(async (conditionalOrderId) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        if (!conditionalOrderId?.trim())
+            throw new Error("Conditional order ID is required and cannot be empty");
+        return await sdk.trading.cancelConditionalOrder(conditionalOrderId);
+    }, [sdk]);
+    const listConditionalOrders = useCallback(async (params) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        return await sdk.trading.listConditionalOrders(params);
+    }, [sdk]);
     const batchCancel = useCallback(async (orderIds) => {
         if (!sdk)
             throw new Error("SDK not available");
@@ -100,6 +117,9 @@ export const useTrade = () => {
         placeMarketOrder,
         // Order management
         cancelOrder,
+        createConditionalOrder,
+        cancelConditionalOrder,
+        listConditionalOrders,
         batchCancel,
         batchCancelAll,
         replaceOrder,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0xmonaco/react",
-	"version": "0.0.0-develop-20260415185155",
+	"version": "0.0.0-develop-20260420223958",
 	"type": "module",
 	"repository": {
 		"type": "git",
@@ -20,8 +20,8 @@
 		"lint": "biome lint ."
 	},
 	"dependencies": {
-		"@0xmonaco/core": "0.0.0-develop-20260415185155",
-		"@0xmonaco/types": "0.0.0-develop-20260415185155"
+		"@0xmonaco/core": "0.0.0-develop-20260420223958",
+		"@0xmonaco/types": "0.0.0-develop-20260420223958"
 	},
 	"devDependencies": {
 		"@types/react": "^19.1.12",