@0xmonaco/react 0.7.7 → 0.7.9

package/dist/hooks/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./useAuth";
+export * from "./useFees";
+export * from "./useMarket";
+export * from "./useMonaco";
+export * from "./useOHLCV";
+export * from "./useOrderbook";
+export * from "./usePositions";
+export * from "./useProfile";
+export * from "./useTokenLifecycle";
+export * from "./useTrade";
+export * from "./useTradeFeed";
+export * from "./useUserBalances";
+export * from "./useUserMovements";
+export * from "./useUserOrders";
+export * from "./useVault";

package/dist/hooks/index.js

@@ -0,0 +1,15 @@
+export * from "./useAuth";
+export * from "./useFees";
+export * from "./useMarket";
+export * from "./useMonaco";
+export * from "./useOHLCV";
+export * from "./useOrderbook";
+export * from "./usePositions";
+export * from "./useProfile";
+export * from "./useTokenLifecycle";
+export * from "./useTrade";
+export * from "./useTradeFeed";
+export * from "./useUserBalances";
+export * from "./useUserMovements";
+export * from "./useUserOrders";
+export * from "./useVault";

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

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

package/dist/hooks/useAuth/index.js

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

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

@@ -0,0 +1,30 @@
+import type { AuthState, ChallengeResponse, TokenRefreshResponse } from "@0xmonaco/types";
+import type { AuthenticationStatus } from "../../provider";
+export interface UseAuthState {
+    /** Current authentication status */
+    authenticationStatus: AuthenticationStatus;
+}
+export interface UseAuthReturn extends UseAuthState {
+    /**
+     * Complete authentication flow. Returns AuthState with accessToken and refreshToken.
+     * @param options - Optional configuration
+     * @param options.connectWebSocket - Auto-connect all authenticated WebSocket channels after login (currently Orders) (default: false)
+     */
+    login: (options?: {
+        connectWebSocket?: boolean;
+    }) => Promise<AuthState>;
+    /** Logout user and clear state. Revokes the refresh token on the server. */
+    logout: () => Promise<void>;
+    /** Refresh authentication tokens using the stored refresh token. */
+    refreshAuth: () => Promise<AuthState>;
+    /** Sign a challenge message with the connected wallet. */
+    signChallenge: (message: string) => Promise<string>;
+    /** Create authentication challenge for the given address. */
+    createChallenge: (address: string) => Promise<ChallengeResponse>;
+    /** Complete authentication with signature. Returns tokens. */
+    authenticate: () => Promise<AuthState>;
+    /** Refresh access token. Pass the refreshToken from authState. */
+    refreshToken: (refreshToken: string) => Promise<TokenRefreshResponse>;
+    /** Revoke the current session's refresh token on the server. */
+    revokeToken: () => Promise<void>;
+}

package/dist/hooks/useAuth/useAuth.d.ts

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

package/dist/hooks/useAuth/useAuth.js

@@ -0,0 +1,145 @@
+import { useCallback } from "react";
+import { AuthenticationStatus, useMonacoContext } from "../../provider";
+import { useMonacoSDK } from "../useMonaco";
+export const useAuth = () => {
+    const { sdk, clientId } = useMonacoSDK();
+    const { authenticationStatus, setAuthenticationStatus, tokenLifecycle, isWalletConnected } = useMonacoContext();
+    const login = useCallback(async () => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        if (!isWalletConnected)
+            throw new Error("Wallet not connected");
+        setAuthenticationStatus(AuthenticationStatus.AUTHENTICATING);
+        try {
+            const authState = await sdk.login(clientId);
+            // Initialize token lifecycle management (caching + auto-refresh)
+            tokenLifecycle.initializeTokens(authState);
+            const authenticated = sdk.isAuthenticated();
+            setAuthenticationStatus(authenticated ? AuthenticationStatus.AUTHENTICATED : AuthenticationStatus.UNAUTHENTICATED);
+            return authState;
+        }
+        catch (error) {
+            setAuthenticationStatus(AuthenticationStatus.UNAUTHENTICATED);
+            throw error;
+        }
+    }, [sdk, isWalletConnected, clientId, setAuthenticationStatus, tokenLifecycle]);
+    const logout = useCallback(async () => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        setAuthenticationStatus(AuthenticationStatus.AUTHENTICATING);
+        try {
+            await sdk.logout();
+            // Clear cached tokens and stop auto-refresh
+            tokenLifecycle.clearTokens();
+            setAuthenticationStatus(AuthenticationStatus.UNAUTHENTICATED);
+        }
+        catch (error) {
+            // Clear tokens even if logout fails
+            tokenLifecycle.clearTokens();
+            setAuthenticationStatus(AuthenticationStatus.UNAUTHENTICATED);
+            throw error;
+        }
+    }, [sdk, setAuthenticationStatus, tokenLifecycle]);
+    const refreshAuth = useCallback(async () => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        setAuthenticationStatus(AuthenticationStatus.AUTHENTICATING);
+        try {
+            const result = await sdk.refreshAuth();
+            // Reinitialize the token lifecycle with new tokens
+            tokenLifecycle.initializeTokens(result);
+            const authenticated = sdk.isAuthenticated();
+            setAuthenticationStatus(authenticated ? AuthenticationStatus.AUTHENTICATED : AuthenticationStatus.UNAUTHENTICATED);
+            return result;
+        }
+        catch (error) {
+            tokenLifecycle.clearTokens();
+            setAuthenticationStatus(AuthenticationStatus.UNAUTHENTICATED);
+            throw error;
+        }
+    }, [sdk, setAuthenticationStatus, tokenLifecycle]);
+    const signChallenge = useCallback(async (message) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        if (!message?.trim())
+            throw new Error("Message is required and cannot be empty");
+        return await sdk.auth.signChallenge(message);
+    }, [sdk]);
+    const createChallenge = useCallback(async (address) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        if (!address?.trim())
+            throw new Error("Address is required and cannot be empty");
+        if (!clientId?.trim())
+            throw new Error("Client ID is required and cannot be empty");
+        return await sdk.auth.createChallenge(address, clientId);
+    }, [sdk, clientId]);
+    const authenticate = useCallback(async () => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        if (!clientId?.trim())
+            throw new Error("Client ID is required and cannot be empty");
+        setAuthenticationStatus(AuthenticationStatus.AUTHENTICATING);
+        try {
+            const result = await sdk.auth.authenticate(clientId);
+            const authenticated = sdk.isAuthenticated();
+            setAuthenticationStatus(authenticated ? AuthenticationStatus.AUTHENTICATED : AuthenticationStatus.UNAUTHENTICATED);
+            return {
+                accessToken: result.accessToken,
+                refreshToken: result.refreshToken,
+                expiresAt: result.expiresAt,
+                user: result.user,
+            };
+        }
+        catch (error) {
+            setAuthenticationStatus(AuthenticationStatus.UNAUTHENTICATED);
+            throw error;
+        }
+    }, [sdk, clientId, setAuthenticationStatus]);
+    const refreshToken = useCallback(async (token) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        if (!token?.trim())
+            throw new Error("Refresh token is required and cannot be empty");
+        setAuthenticationStatus(AuthenticationStatus.AUTHENTICATING);
+        try {
+            const result = await sdk.auth.refreshToken(token);
+            const authenticated = sdk.isAuthenticated();
+            setAuthenticationStatus(authenticated ? AuthenticationStatus.AUTHENTICATED : AuthenticationStatus.UNAUTHENTICATED);
+            return result;
+        }
+        catch (error) {
+            setAuthenticationStatus(AuthenticationStatus.UNAUTHENTICATED);
+            throw error;
+        }
+    }, [sdk, setAuthenticationStatus]);
+    const revokeToken = useCallback(async () => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        setAuthenticationStatus(AuthenticationStatus.AUTHENTICATING);
+        try {
+            await sdk.auth.revokeToken();
+            const authenticated = sdk.isAuthenticated();
+            setAuthenticationStatus(authenticated ? AuthenticationStatus.AUTHENTICATED : AuthenticationStatus.UNAUTHENTICATED);
+        }
+        catch (error) {
+            setAuthenticationStatus(AuthenticationStatus.UNAUTHENTICATED);
+            throw error;
+        }
+    }, [sdk, setAuthenticationStatus]);
+    return {
+        // State
+        authenticationStatus,
+        // Primary auth actions
+        login,
+        logout,
+        // Token management
+        refreshAuth,
+        refreshToken,
+        revokeToken,
+        // Low-level auth functions
+        authenticate,
+        signChallenge,
+        createChallenge,
+    };
+};

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

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

package/dist/hooks/useFees/index.js

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

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

@@ -0,0 +1,5 @@
+import type { SimulateFeeParams, SimulateFeeResponse } from "@0xmonaco/types";
+export interface UseFeesReturn {
+    /** Simulate fees for an order before placing it */
+    simulateFees: (params: SimulateFeeParams) => Promise<SimulateFeeResponse>;
+}

package/dist/hooks/useFees/useFees.d.ts

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

package/dist/hooks/useFees/useFees.js

@@ -0,0 +1,14 @@
+import { useCallback } from "react";
+import { useMonacoSDK } from "../useMonaco";
+export const useFees = () => {
+    const { sdk } = useMonacoSDK();
+    const simulateFees = useCallback(async (params) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        // Parameter validation is handled by the SDK core using Zod
+        return await sdk.fees.simulateFees(params);
+    }, [sdk]);
+    return {
+        simulateFees,
+    };
+};

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

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

package/dist/hooks/useMarket/index.js

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

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

@@ -0,0 +1,30 @@
+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>;
+    /** Get a specific trading pair by symbol */
+    getTradingPairBySymbol: (symbol: string) => Promise<TradingPair | undefined>;
+    /**
+     * Get candlestick data for a trading pair.
+     *
+     * Supports TradingView-compliant query patterns:
+     * - `endTime` + `limit`: Backward pagination (bars ending at timestamp)
+     * - `startTime` + `limit`: Forward pagination (bars starting from timestamp)
+     * - `limit` only: Most recent bars
+     * - `startTime` + `endTime` + `limit`: Specific range (capped at limit)
+     *
+     * @param tradingPairId - Trading pair UUID
+     * @param interval - Candlestick interval (1m, 5m, 15m, 1h, 4h, 1d)
+     * @param params - Optional query parameters (startTime, endTime, limit)
+     */
+    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.d.ts

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

package/dist/hooks/useMarket/useMarket.js

@@ -0,0 +1,92 @@
+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");
+        return await sdk.market.getPaginatedTradingPairs(params);
+    }, [sdk]);
+    const getTradingPairBySymbol = useCallback(async (symbol) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        if (!symbol?.trim())
+            throw new Error("Symbol is required and cannot be empty");
+        return await sdk.market.getTradingPairBySymbol(symbol);
+    }, [sdk]);
+    const getCandlesticks = useCallback(async (tradingPairId, interval, params) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        if (!tradingPairId?.trim())
+            throw new Error("Trading pair ID is required and cannot be empty");
+        if (!interval)
+            throw new Error("Interval is required");
+        return await sdk.market.getCandlesticks(tradingPairId, interval, params);
+    }, [sdk]);
+    const getMarketMetadata = useCallback(async (pairId) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        if (!pairId?.trim())
+            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/useMonaco/index.d.ts

@@ -0,0 +1,2 @@
+export type { UseMonacoReturn } from "./types";
+export { useMonacoSDK } from "./useMonaco";

package/dist/hooks/useMonaco/index.js

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

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

@@ -0,0 +1,13 @@
+import type { MonacoSDK } from "@0xmonaco/types";
+export interface UseMonacoReturn {
+    /** Monaco SDK instance */
+    sdk: MonacoSDK | null;
+    /** Client ID for authentication */
+    clientId: string;
+    /** Any error that occurred (SDK initialization, authentication, etc.) */
+    error: Error | null;
+    /** Clear the current error state */
+    clearError: () => void;
+    /** Set an error state */
+    setError: (error: Error | null) => void;
+}

package/dist/hooks/useMonaco/useMonaco.d.ts

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

package/dist/hooks/useMonaco/useMonaco.js

@@ -0,0 +1,13 @@
+import { useCallback } from "react";
+import { useMonacoContext } from "../../provider";
+export const useMonacoSDK = () => {
+    const { sdk, clientId, error, setError } = useMonacoContext();
+    const clearError = useCallback(() => setError(null), [setError]);
+    return {
+        sdk,
+        clientId,
+        error,
+        clearError,
+        setError,
+    };
+};

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

@@ -0,0 +1,2 @@
+export * from "./types";
+export { useOHLCV } from "./useOHLCV";

package/dist/hooks/useOHLCV/index.js

@@ -0,0 +1,2 @@
+export * from "./types";
+export { useOHLCV } from "./useOHLCV";

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

@@ -0,0 +1,29 @@
+import type { Candlestick, GetCandlesticksParams, Interval, TradingMode } from "@0xmonaco/types";
+/**
+ * Parameters for the useOHLCV hook
+ */
+export interface UseOHLCVParams {
+    /** Trading pair UUID */
+    tradingPairId: string;
+    /** Trading mode (e.g., "CLOB") */
+    tradingMode: TradingMode;
+    /** Candlestick interval (1m, 5m, 15m, 1h, 4h, 1d) */
+    interval: Interval;
+    /** Optional parameters for initial candlestick fetch */
+    initialFetchParams?: GetCandlesticksParams;
+}
+/**
+ * Return type for the useOHLCV hook
+ */
+export interface UseOHLCVReturn {
+    /** Array of candlesticks (oldest to newest) */
+    candlesticks: Candlestick[];
+    /** Whether the initial candlesticks are being fetched */
+    loading: boolean;
+    /** Whether currently subscribed to WebSocket updates */
+    subscribed: boolean;
+    /** Any error that occurred during connection or subscription */
+    error: Error | null;
+    /** Clear the current error */
+    clearError: () => void;
+}

package/dist/hooks/useOHLCV/useOHLCV.d.ts

@@ -0,0 +1,11 @@
+import type { UseOHLCVParams, UseOHLCVReturn } from "./types";
+/**
+ * Hook for subscribing to real-time OHLCV candlestick events via WebSocket (public)
+ *
+ * Fetches initial candlesticks from the REST API, then subscribes to real-time updates.
+ * When a new candlestick event arrives, it either updates the most recent candlestick
+ * (if timestamps match) or appends a new one.
+ *
+ * @param params - Configuration including tradingPairId, tradingMode, interval, and optional fetch params
+ */
+export declare function useOHLCV(params: UseOHLCVParams): UseOHLCVReturn;

package/dist/hooks/useOHLCV/useOHLCV.js

@@ -0,0 +1,76 @@
+import { useCallback, useEffect, useState } from "react";
+import { useMonacoSDK } from "../useMonaco";
+/**
+ * Hook for subscribing to real-time OHLCV candlestick events via WebSocket (public)
+ *
+ * Fetches initial candlesticks from the REST API, then subscribes to real-time updates.
+ * When a new candlestick event arrives, it either updates the most recent candlestick
+ * (if timestamps match) or appends a new one.
+ *
+ * @param params - Configuration including tradingPairId, tradingMode, interval, and optional fetch params
+ */
+export function useOHLCV(params) {
+    const { tradingPairId, tradingMode, interval, initialFetchParams } = params;
+    const { sdk } = useMonacoSDK();
+    const [candlesticks, setCandlesticks] = useState([]);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [subscribed, setSubscribed] = useState(false);
+    const clearError = useCallback(() => setError(null), []);
+    useEffect(() => {
+        if (!sdk?.ws || !sdk?.market || !tradingPairId || !tradingMode || !interval) {
+            setSubscribed(false);
+            setLoading(false);
+            return;
+        }
+        setCandlesticks([]);
+        setError(null);
+        setLoading(true);
+        let unsubscribe;
+        let cancelled = false;
+        sdk.market
+            .getCandlesticks(tradingPairId, interval, initialFetchParams)
+            .then((initialCandlesticks) => {
+            if (cancelled)
+                return;
+            setCandlesticks(initialCandlesticks);
+            try {
+                unsubscribe = sdk.ws.ohlcv(tradingPairId, tradingMode, interval, (event) => {
+                    setCandlesticks((prev) => {
+                        if (prev.length === 0) {
+                            return [event.candlestick];
+                        }
+                        const lastCandle = prev[prev.length - 1];
+                        if (lastCandle && lastCandle.T === event.candlestick.T) {
+                            const updated = [...prev];
+                            updated[updated.length - 1] = event.candlestick;
+                            return updated;
+                        }
+                        return [...prev, event.candlestick];
+                    });
+                });
+                setSubscribed(true);
+            }
+            catch (err) {
+                setError(err instanceof Error ? err : new Error(String(err)));
+                setSubscribed(false);
+            }
+        })
+            .catch((err) => {
+            if (!cancelled) {
+                setError(err instanceof Error ? err : new Error(String(err)));
+            }
+        })
+            .finally(() => {
+            if (!cancelled) {
+                setLoading(false);
+            }
+        });
+        return () => {
+            cancelled = true;
+            unsubscribe?.();
+            setSubscribed(false);
+        };
+    }, [sdk?.ws, sdk?.market, tradingPairId, tradingMode, interval, initialFetchParams]);
+    return { candlesticks, loading, subscribed, error, clearError };
+}

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

@@ -0,0 +1,2 @@
+export type { OrderbookSubscriptionRef, UseOrderbookReturn } from "./types";
+export { useOrderbook } from "./useOrderbook";

package/dist/hooks/useOrderbook/index.js

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

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

@@ -0,0 +1,27 @@
+import type { OrderbookEvent, OrderbookQuotationMode, TradingMode } from "@0xmonaco/types";
+/**
+ * State structure for current subscription ref
+ */
+export interface OrderbookSubscriptionRef {
+    /** The pair subscribed to */
+    pair: string;
+    /** The mode subscribed to */
+    mode: TradingMode;
+    /** The magnitude for orderbook grouping */
+    magnitude?: number;
+    /** The quotation mode for orderbook subscription */
+    quotationMode?: OrderbookQuotationMode;
+}
+/**
+ * Return type for the useOrderbook hook
+ */
+export interface UseOrderbookReturn {
+    /** Current orderbook snapshot */
+    orderbook: OrderbookEvent | null;
+    /** Whether currently subscribed to a market */
+    subscribed: boolean;
+    /** Any error that occurred during connection or subscription */
+    error: Error | null;
+    /** Clear the current error state */
+    clearError: () => void;
+}

package/dist/hooks/useOrderbook/useOrderbook.d.ts

@@ -0,0 +1,3 @@
+import type { OrderbookQuotationMode, TradingMode } from "@0xmonaco/types";
+import type { UseOrderbookReturn } from "./types";
+export declare function useOrderbook(tradingPairId: string, tradingMode: TradingMode, magnitude: number, quotationMode: OrderbookQuotationMode, depth?: number): UseOrderbookReturn;

package/dist/hooks/useOrderbook/useOrderbook.js

@@ -0,0 +1,31 @@
+import { useCallback, useEffect, useState } from "react";
+import { useMonacoSDK } from "../useMonaco";
+export function useOrderbook(tradingPairId, tradingMode, magnitude, quotationMode, depth = 10) {
+    const { sdk } = useMonacoSDK();
+    const [orderbook, setOrderbook] = useState(null);
+    const [error, setError] = useState(null);
+    const [subscribed, setSubscribed] = useState(false);
+    const clearError = useCallback(() => setError(null), []);
+    // Connect and subscribe to orderbook updates
+    useEffect(() => {
+        if (!sdk?.ws || !sdk?.orderbook || !tradingPairId) {
+            setSubscribed(false);
+            return;
+        }
+        setOrderbook(null);
+        setError(null);
+        // Fetch initial orderbook via REST
+        sdk.orderbook
+            .getOrderbook(tradingPairId, { depth, tradingMode, magnitude, denomination: quotationMode })
+            .then((initial) => setOrderbook(initial))
+            .catch((err) => setError(err instanceof Error ? err : new Error(String(err))));
+        // Subscribe to WebSocket updates (ws connection handled by MonacoProvider)
+        const unsubscribe = sdk.ws.orderbook(tradingPairId, tradingMode, magnitude, quotationMode, setOrderbook);
+        setSubscribed(true);
+        return () => {
+            unsubscribe();
+            setSubscribed(false);
+        };
+    }, [sdk?.ws, sdk?.orderbook, tradingPairId, tradingMode, magnitude, quotationMode, depth]);
+    return { orderbook, subscribed, error, clearError };
+}

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";