@0xmonaco/react 0.6.3 → 0.7.1

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,7 +1,7 @@
-import type { Candlestick, GetCandlesticksParams, GetTradingPairsParams, Interval, MarketMetadata, PaginatedTradingPairs, 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<PaginatedTradingPairs>;
+    getPaginatedTradingPairs: (params?: GetTradingPairsParams) => Promise<GetTradingPairsResponse>;
     /** Get a specific trading pair by symbol */
     getTradingPairBySymbol: (symbol: string) => Promise<TradingPair | undefined>;
     /**
@@ -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,15 +1,15 @@
 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) => {
         if (!sdk)
             throw new Error("SDK not available");
-        const response = await sdk.market.getPaginatedTradingPairs(params);
-        if (!response.success) {
-            throw new Error("Failed to fetch trading pairs");
-        }
-        return response.data;
+        return await sdk.market.getPaginatedTradingPairs(params);
     }, [sdk]);
     const getTradingPairBySymbol = useCallback(async (symbol) => {
         if (!sdk)
@@ -34,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/useProfile/useProfile.js

@@ -51,8 +51,8 @@ export const useProfile = () => {
         try {
             const [userProfileResult, balancesResult, movementsResult, ordersResult] = await Promise.allSettled([
                 sdk.profile.getProfile(),
-                sdk.profile.getUserBalances({ limit: DEFAULT_PAGE_SIZE, offset: 0 }),
-                sdk.profile.getPaginatedUserMovements({ page: 1, limit: DEFAULT_PAGE_SIZE }),
+                sdk.profile.getUserBalances({ page_size: DEFAULT_PAGE_SIZE, page: 1 }),
+                sdk.profile.getPaginatedUserMovements({ page: 1, page_size: DEFAULT_PAGE_SIZE }),
                 sdk.trading.getPaginatedOrders({ page: 1, page_size: DEFAULT_PAGE_SIZE }),
             ]);
             const userProfile = getSettledValueOrThrow(userProfileResult);

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/dist/hooks/useTradeFeed/useTradeFeed.js

@@ -19,7 +19,7 @@ export function useTradeFeed(tradingPairId) {
         if (!sdk?.ws || !sdk?.trades || !tradingPairId) {
             return;
         }
-        const fetchInitialTrades = () => sdk.trades.getTrades(tradingPairId, { limit: MAX_TRADES });
+        const fetchInitialTrades = () => sdk.trades.getTrades(tradingPairId, { page_size: MAX_TRADES });
         const subscribeToWs = (handler) => sdk.ws.trades(tradingPairId, handler);
         return subscribe(tradingPairId, fetchInitialTrades, subscribeToWs);
     }, [sdk?.ws, sdk?.trades, tradingPairId, subscribe]);

package/dist/hooks/useUserMovements/useUserMovements.d.ts

@@ -10,7 +10,7 @@ import type { UseUserMovementsOptions, UseUserMovementsReturn } from "./types";
  *
  * @param options - Optional filter and pagination options
  * @param options.maxMovements - Maximum number of movements to keep in state (default: 50)
- * @param options.limit - Number of items per page for the API call (default: maxMovements)
+ * @param options.page_size - Number of items per page for the API call (default: maxMovements)
  * @param options.entry_type - Filter by entry type (CREDIT, DEBIT, LOCK, UNLOCK, FEE)
  * @param options.transaction_type - Filter by transaction type (DEPOSIT, WITHDRAWAL, TRADE, etc.)
  * @param options.asset_id - Filter by asset ID (UUID)

package/dist/hooks/useUserMovements/useUserMovements.js

@@ -44,7 +44,7 @@ function ledgerMovementToEvent(movement, userId) {
  *
  * @param options - Optional filter and pagination options
  * @param options.maxMovements - Maximum number of movements to keep in state (default: 50)
- * @param options.limit - Number of items per page for the API call (default: maxMovements)
+ * @param options.page_size - Number of items per page for the API call (default: maxMovements)
  * @param options.entry_type - Filter by entry type (CREDIT, DEBIT, LOCK, UNLOCK, FEE)
  * @param options.transaction_type - Filter by transaction type (DEPOSIT, WITHDRAWAL, TRADE, etc.)
  * @param options.asset_id - Filter by asset ID (UUID)
@@ -52,14 +52,14 @@ function ledgerMovementToEvent(movement, userId) {
 export function useUserMovements(options = {}) {
     const { sdk } = useMonacoSDK();
     const { authenticationStatus } = useMonacoContext();
-    const { maxMovements = 50, limit, entry_type, transaction_type, asset_id } = options;
+    const { maxMovements = 50, page_size, entry_type, transaction_type, asset_id } = options;
     const [movements, setMovements] = useState([]);
     const [loading, setLoading] = useState(false);
     const [error, setError] = useState(null);
     const [subscribed, setSubscribed] = useState(false);
     const clearError = useCallback(() => setError(null), []);
     const sliceSize = Number.isFinite(maxMovements) && maxMovements > 0 ? maxMovements : 50;
-    const requestLimit = limit ?? Math.min(Math.max(Math.round(sliceSize), 1), 100);
+    const requestLimit = page_size ?? Math.min(Math.max(Math.round(sliceSize), 1), 100);
     // Derive userId reactively — authenticationStatus changes on login/logout, triggering a re-render
     const userId = authenticationStatus === "authenticated" ? sdk?.getAuthState()?.user.id : undefined;
     useEffect(() => {
@@ -73,7 +73,7 @@ export function useUserMovements(options = {}) {
         // Fetch initial movements via REST API, then subscribe to WebSocket updates
         let unsubscribe;
         sdk.profile
-            .getPaginatedUserMovements({ limit: requestLimit, entry_type, transaction_type, asset_id })
+            .getPaginatedUserMovements({ page_size: requestLimit, entry_type, transaction_type, asset_id })
             .then(async (response) => {
             // Combine latest_movements (from Redis) with movements (from PostgreSQL)
             // latest_movements contains real-time data that may not yet be in PostgreSQL

package/dist/hooks/useUserOrders/useUserOrders.js

@@ -118,12 +118,12 @@ function orderFromEvent(event) {
     if (event.eventType !== "OrderPlaced")
         return null;
     const { data } = event;
-    const tradingPair = data.tradingPairId || data.tradingPair;
-    if (!tradingPair)
+    const tradingPairId = data.tradingPairId || data.symbol;
+    if (!tradingPairId)
         return null;
     return {
         id: event.orderId,
-        trading_pair: tradingPair,
+        trading_pair_id: tradingPairId,
         order_type: (data.orderType || "LIMIT"),
         side: (data.side || "BUY"),
         price: data.price,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0xmonaco/react",
-	"version": "0.6.3",
+	"version": "0.7.1",
 	"type": "module",
 	"repository": {
 		"type": "git",