@0xmonaco/react 0.7.6 → 0.7.7

package/dist/hooks/useTrade/useTrade.js

@@ -1,132 +0,0 @@
-import { useCallback } from "react";
-import { useMonacoSDK } from "../useMonaco";
-export const useTrade = () => {
-    const { sdk } = useMonacoSDK();
-    const placeLimitOrder = useCallback(async (tradingPairId, side, quantity, price, options) => {
-        if (!sdk)
-            throw new Error("SDK not available");
-        if (!tradingPairId?.trim())
-            throw new Error("Trading pair ID is required and cannot be empty");
-        if (!side)
-            throw new Error("Order side is required");
-        if (!quantity?.trim())
-            throw new Error("Quantity is required and cannot be empty");
-        if (!price?.trim())
-            throw new Error("Price is required and cannot be empty");
-        if (Number(quantity) <= 0)
-            throw new Error("Quantity must be greater than 0");
-        if (Number(price) <= 0)
-            throw new Error("Price must be greater than 0");
-        return await sdk.trading.placeLimitOrder(tradingPairId, side, quantity, price, options);
-    }, [sdk]);
-    const placeMarketOrder = useCallback(async (tradingPairId, side, quantity, options) => {
-        if (!sdk)
-            throw new Error("SDK not available");
-        if (!tradingPairId?.trim())
-            throw new Error("Trading pair ID is required and cannot be empty");
-        if (!side)
-            throw new Error("Order side is required");
-        if (!quantity?.trim())
-            throw new Error("Quantity is required and cannot be empty");
-        if (Number(quantity) <= 0)
-            throw new Error("Quantity must be greater than 0");
-        return await sdk.trading.placeMarketOrder(tradingPairId, side, quantity, options);
-    }, [sdk]);
-    const cancelOrder = useCallback(async (orderId) => {
-        if (!sdk)
-            throw new Error("SDK not available");
-        if (!orderId?.trim())
-            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");
-        return await sdk.trading.batchCancel(orderIds);
-    }, [sdk]);
-    const batchCancelAll = useCallback(async (tradingPairId) => {
-        if (!sdk)
-            throw new Error("SDK not available");
-        return await sdk.trading.batchCancelAll(tradingPairId);
-    }, [sdk]);
-    const replaceOrder = useCallback(async (orderId, newOrder) => {
-        if (!sdk)
-            throw new Error("SDK not available");
-        if (!orderId?.trim())
-            throw new Error("Order ID is required and cannot be empty");
-        if (!newOrder)
-            throw new Error("New order object is required");
-        // Validate quantity only if provided
-        if (newOrder.quantity !== undefined) {
-            if (!newOrder.quantity?.trim())
-                throw new Error("Quantity cannot be empty");
-            if (Number(newOrder.quantity) <= 0)
-                throw new Error("Quantity must be greater than 0");
-        }
-        // Validate price only if provided
-        if (newOrder.price !== undefined) {
-            if (!newOrder.price?.trim())
-                throw new Error("Price cannot be empty");
-            if (Number(newOrder.price) <= 0)
-                throw new Error("Price must be a valid positive number");
-        }
-        return await sdk.trading.replaceOrder(orderId, newOrder);
-    }, [sdk]);
-    const batchCreate = useCallback(async (orders) => {
-        if (!sdk)
-            throw new Error("SDK not available");
-        return await sdk.trading.batchCreate(orders);
-    }, [sdk]);
-    const batchReplace = useCallback(async (orders) => {
-        if (!sdk)
-            throw new Error("SDK not available");
-        return await sdk.trading.batchReplace(orders);
-    }, [sdk]);
-    const getPaginatedOrders = useCallback(async (params) => {
-        if (!sdk)
-            throw new Error("SDK not available");
-        return await sdk.trading.getPaginatedOrders(params);
-    }, [sdk]);
-    const getOrder = useCallback(async (orderId) => {
-        if (!sdk)
-            throw new Error("SDK not available");
-        if (!orderId?.trim())
-            throw new Error("Order ID is required and cannot be empty");
-        return await sdk.trading.getOrder(orderId);
-    }, [sdk]);
-    return {
-        // Order placement
-        placeLimitOrder,
-        placeMarketOrder,
-        // Order management
-        cancelOrder,
-        createConditionalOrder,
-        cancelConditionalOrder,
-        listConditionalOrders,
-        batchCancel,
-        batchCancelAll,
-        replaceOrder,
-        batchCreate,
-        batchReplace,
-        // Order queries
-        getPaginatedOrders,
-        getOrder,
-    };
-};

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

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

package/dist/hooks/useTradeFeed/index.js

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

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

@@ -1,14 +0,0 @@
-import type { TradeEvent } from "@0xmonaco/types";
-/**
- * Return type for the useTradeFeed hook
- */
-export interface UseTradeFeedReturn {
-    /** Array of trade events from WebSocket and REST API */
-    trades: TradeEvent[];
-    /** Whether currently subscribed to a market. Will be false if the SDK is not yet initialized. */
-    subscribed: boolean;
-    /** Whether the initial trades are being fetched */
-    fetchingInitialState: boolean;
-    /** Any error that occurred during connection or subscription */
-    error: Error | null;
-}

package/dist/hooks/useTradeFeed/useTradeFeed.d.ts

@@ -1,12 +0,0 @@
-import type { UseTradeFeedReturn } from "./types";
-/**
- * Hook for subscribing to real-time trade events via WebSocket (public)
- *
- * Subscriptions are shared at the provider level - multiple components using the same
- * tradingPairId will share both the WebSocket connection and the trade state.
- * Initial trades are fetched only once when the first component subscribes.
- * The last 50 trades are kept in state (this limit is fixed and not configurable).
- *
- * @param tradingPairId - The trading pair UUID to subscribe to
- */
-export declare function useTradeFeed(tradingPairId: string): UseTradeFeedReturn;

package/dist/hooks/useTradeFeed/useTradeFeed.js

@@ -1,32 +0,0 @@
-import { useEffect } from "react";
-import { MAX_TRADES, useTradeFeedContext } from "../../provider";
-import { useMonacoSDK } from "../useMonaco";
-/**
- * Hook for subscribing to real-time trade events via WebSocket (public)
- *
- * Subscriptions are shared at the provider level - multiple components using the same
- * tradingPairId will share both the WebSocket connection and the trade state.
- * Initial trades are fetched only once when the first component subscribes.
- * The last 50 trades are kept in state (this limit is fixed and not configurable).
- *
- * @param tradingPairId - The trading pair UUID to subscribe to
- */
-export function useTradeFeed(tradingPairId) {
-    const { sdk } = useMonacoSDK();
-    const { subscribe, subscriptions } = useTradeFeedContext();
-    const subscription = subscriptions.get(tradingPairId);
-    useEffect(() => {
-        if (!sdk?.ws || !sdk?.trades || !tradingPairId) {
-            return;
-        }
-        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]);
-    return {
-        trades: subscription?.trades ?? [],
-        subscribed: subscription?.subscribed ?? false,
-        fetchingInitialState: subscription?.fetchingInitialState ?? false,
-        error: subscription?.error ?? null,
-    };
-}

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

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

package/dist/hooks/useUserBalances/index.js

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

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

@@ -1,18 +0,0 @@
-import type { AccountBalance } from "@0xmonaco/types";
-/**
- * Return type for the useUserBalances hook
- */
-export interface UseUserBalancesReturn {
-    /** Array of user balances, updated in real-time via WebSocket */
-    balances: AccountBalance[];
-    /** Whether initial data is being loaded */
-    loading: boolean;
-    /** Whether currently subscribed to balances channel */
-    subscribed: boolean;
-    /** Any error that occurred during connection or subscription */
-    error: Error | null;
-    /** Clear the current error state */
-    clearError: () => void;
-    /** Manually refresh balances from REST API */
-    refresh: () => Promise<void>;
-}

package/dist/hooks/useUserBalances/useUserBalances.d.ts

@@ -1,9 +0,0 @@
-import type { UseUserBalancesReturn } from "./types";
-/**
- * Hook for subscribing to real-time user balance updates via WebSocket (authenticated)
- *
- * Fetches initial balances from the REST API, then subscribes to real-time updates.
- * Requires authentication - the user must be logged in with a valid JWT token.
- * User is identified on the backend via the JWT token.
- */
-export declare function useUserBalances(): UseUserBalancesReturn;

package/dist/hooks/useUserBalances/useUserBalances.js

@@ -1,171 +0,0 @@
-import { useCallback, useEffect, useState } from "react";
-import { useMonacoSDK } from "../useMonaco";
-/**
- * Update an AccountBalance with data from a WebSocket balance event
- */
-function updateBalanceFromEvent(balance, event) {
-    const totalBalance = totalBalanceFromEvent(balance, event);
-    return {
-        ...balance,
-        available_balance: event.data.available,
-        available_balance_raw: event.data.availableRaw,
-        locked_balance: event.data.locked,
-        locked_balance_raw: event.data.lockedRaw,
-        total_balance: totalBalance,
-    };
-}
-function parseDecimal(value) {
-    const match = value.trim().match(/^(-?)(\d+)(?:\.(\d+))?$/);
-    if (!match)
-        return null;
-    const [, sign, whole, fractional = ""] = match;
-    const digits = `${whole}${fractional}`.replace(/^0+(?=\d)/, "");
-    const parsed = BigInt(digits || "0");
-    return {
-        value: sign === "-" ? -parsed : parsed,
-        scale: fractional.length,
-    };
-}
-function pow10(exponent) {
-    return 10n ** BigInt(exponent);
-}
-function toScale(value, scale) {
-    return value.value * pow10(scale - value.scale);
-}
-function formatDecimal(value, scale) {
-    const sign = value < 0n ? "-" : "";
-    const absolute = value < 0n ? -value : value;
-    if (scale === 0)
-        return `${sign}${absolute.toString()}`;
-    const padded = absolute.toString().padStart(scale + 1, "0");
-    const whole = padded.slice(0, -scale);
-    const fractional = padded.slice(-scale).replace(/0+$/, "");
-    return fractional ? `${sign}${whole}.${fractional}` : `${sign}${whole}`;
-}
-function decimalSum(...values) {
-    const parsed = values.map(parseDecimal);
-    if (parsed.some((value) => value === null))
-        return null;
-    const decimals = parsed;
-    const scale = Math.max(...decimals.map((value) => value.scale));
-    const sum = decimals.reduce((total, value) => total + toScale(value, scale), 0n);
-    return formatDecimal(sum, scale);
-}
-function decimalDifference(left, ...right) {
-    return decimalSum(left, ...right.map((value) => (value.startsWith("-") ? value.slice(1) : `-${value}`)));
-}
-function decimalGreaterThanZero(value) {
-    const parsed = parseDecimal(value);
-    return parsed ? parsed.value > 0n : false;
-}
-function totalBalanceFromEvent(balance, event) {
-    if (event.data.reason === "margin_transfer_in" || event.data.reason === "margin_transfer_out") {
-        return event.data.total;
-    }
-    const eventExtraTotal = decimalDifference(event.data.total, event.data.available, event.data.locked);
-    if (eventExtraTotal && decimalGreaterThanZero(eventExtraTotal)) {
-        return event.data.total;
-    }
-    const previousMarginTotal = decimalDifference(balance.total_balance, balance.available_balance, balance.locked_balance);
-    if (!previousMarginTotal || !decimalGreaterThanZero(previousMarginTotal)) {
-        return event.data.total;
-    }
-    return decimalSum(event.data.total, previousMarginTotal) ?? event.data.total;
-}
-/**
- * Hook for subscribing to real-time user balance updates via WebSocket (authenticated)
- *
- * Fetches initial balances from the REST API, then subscribes to real-time updates.
- * Requires authentication - the user must be logged in with a valid JWT token.
- * User is identified on the backend via the JWT token.
- */
-export function useUserBalances() {
-    const { sdk } = useMonacoSDK();
-    const [balances, setBalances] = useState([]);
-    const [loading, setLoading] = useState(false);
-    const [error, setError] = useState(null);
-    const [subscribed, setSubscribed] = useState(false);
-    const clearError = useCallback(() => setError(null), []);
-    const fetchBalances = useCallback(async () => {
-        if (!sdk?.profile)
-            return;
-        setLoading(true);
-        try {
-            const response = await sdk.profile.getUserBalances();
-            setBalances(response.balances);
-        }
-        catch (err) {
-            setError(err instanceof Error ? err : new Error(String(err)));
-        }
-        finally {
-            setLoading(false);
-        }
-    }, [sdk?.profile]);
-    const refresh = useCallback(async () => {
-        await fetchBalances();
-    }, [fetchBalances]);
-    useEffect(() => {
-        if (!sdk?.ws || !sdk?.profile) {
-            setSubscribed(false);
-            return;
-        }
-        setBalances([]);
-        setError(null);
-        setLoading(true);
-        // Fetch initial balances via REST API, then subscribe to WebSocket updates
-        let unsubscribe;
-        let cancelled = false;
-        fetchBalances()
-            .then(() => {
-            // Bail out if effect was cleaned up before fetch resolved
-            if (cancelled)
-                return;
-            // Subscribe to WebSocket balance updates after initial data is loaded
-            try {
-                unsubscribe = sdk.ws.balances((event) => {
-                    let needsRefresh = false;
-                    setBalances((prev) => {
-                        // Find by token address and update (case-insensitive for addresses)
-                        const existingIndex = prev.findIndex((b) => b.token.toLowerCase() === event.data.tokenAddress.toLowerCase());
-                        const existingBalance = prev[existingIndex];
-                        if (existingIndex >= 0 && existingBalance) {
-                            // Update existing balance
-                            const updatedBalance = updateBalanceFromEvent(existingBalance, event);
-                            const newBalances = [...prev];
-                            newBalances[existingIndex] = updatedBalance;
-                            return newBalances;
-                        }
-                        // New token - flag for refresh outside the updater
-                        needsRefresh = true;
-                        return prev;
-                    });
-                    // Refresh outside the state updater to keep it pure
-                    if (needsRefresh && !cancelled) {
-                        fetchBalances().catch((err) => {
-                            if (!cancelled) {
-                                setError(err instanceof Error ? err : new Error(String(err)));
-                            }
-                        });
-                    }
-                });
-                setSubscribed(true);
-            }
-            catch (err) {
-                setError(err instanceof Error ? err : new Error(String(err)));
-                setSubscribed(false);
-            }
-        })
-            .catch((err) => {
-            if (cancelled)
-                return;
-            setError(err instanceof Error ? err : new Error(String(err)));
-            setLoading(false);
-        });
-        return () => {
-            cancelled = true;
-            unsubscribe?.();
-            setSubscribed(false);
-        };
-    }, [sdk?.ws, sdk?.profile, fetchBalances]);
-    return { balances, loading, subscribed, error, clearError, refresh };
-}

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

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

package/dist/hooks/useUserMovements/index.js

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

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

@@ -1,23 +0,0 @@
-import type { GetUserMovementsParams, UserMovementEvent } from "@0xmonaco/types";
-/**
- * Options for the useUserMovements hook
- */
-export interface UseUserMovementsOptions extends Omit<GetUserMovementsParams, "page"> {
-    /** Maximum number of movements to keep in state (default: 50) */
-    maxMovements?: number;
-}
-/**
- * Return type for the useUserMovements hook
- */
-export interface UseUserMovementsReturn {
-    /** Array of user movement events from WebSocket */
-    movements: UserMovementEvent[];
-    /** Whether initial data is being loaded */
-    loading: boolean;
-    /** Whether currently subscribed to movements channel */
-    subscribed: boolean;
-    /** Any error that occurred during connection or subscription */
-    error: Error | null;
-    /** Clear the current error state */
-    clearError: () => void;
-}

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

@@ -1,18 +0,0 @@
-import type { UseUserMovementsOptions, UseUserMovementsReturn } from "./types";
-/**
- * Hook for subscribing to real-time user movement events via WebSocket (authenticated)
- *
- * Fetches initial movements from the REST API, then subscribes to real-time updates.
- * Requires authentication - the user must be logged in with a valid JWT token.
- * User is identified on the backend via the JWT token.
- *
- * Re-fetches movements whenever filter options change.
- *
- * @param options - Optional filter and pagination options
- * @param options.maxMovements - Maximum number of movements to keep in state (default: 50)
- * @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)
- */
-export declare function useUserMovements(options?: UseUserMovementsOptions): UseUserMovementsReturn;

package/dist/hooks/useUserMovements/useUserMovements.js

@@ -1,122 +0,0 @@
-import { useCallback, useEffect, useState } from "react";
-import { useMonacoContext } from "../../provider";
-import { useMonacoSDK } from "../useMonaco";
-/**
- * Convert a LedgerMovement from the REST API to a UserMovementEvent format
- */
-function ledgerMovementToEvent(movement, userId) {
-    return {
-        eventType: "movement",
-        userId,
-        data: {
-            id: movement.id,
-            entryType: movement.entry_type,
-            transactionType: movement.transaction_type,
-            tokenAddress: movement.token,
-            symbol: movement.symbol ?? undefined,
-            decimals: movement.decimals,
-            amount: movement.amount,
-            amountRaw: movement.amount_raw,
-            balanceBefore: movement.balance_before ?? undefined,
-            balanceBeforeRaw: movement.balance_before_raw ?? undefined,
-            balanceAfter: movement.balance_after ?? undefined,
-            balanceAfterRaw: movement.balance_after_raw ?? undefined,
-            lockedBefore: movement.locked_before ?? undefined,
-            lockedBeforeRaw: movement.locked_before_raw ?? undefined,
-            lockedAfter: movement.locked_after ?? undefined,
-            lockedAfterRaw: movement.locked_after_raw ?? undefined,
-            referenceId: movement.reference_id ?? undefined,
-            referenceType: movement.reference_type ?? undefined,
-            description: movement.description ?? undefined,
-            txHash: movement.tx_hash ?? undefined,
-            createdAt: movement.created_at ?? undefined,
-        },
-    };
-}
-/**
- * Hook for subscribing to real-time user movement events via WebSocket (authenticated)
- *
- * Fetches initial movements from the REST API, then subscribes to real-time updates.
- * Requires authentication - the user must be logged in with a valid JWT token.
- * User is identified on the backend via the JWT token.
- *
- * Re-fetches movements whenever filter options change.
- *
- * @param options - Optional filter and pagination options
- * @param options.maxMovements - Maximum number of movements to keep in state (default: 50)
- * @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)
- */
-export function useUserMovements(options = {}) {
-    const { sdk } = useMonacoSDK();
-    const { authenticationStatus } = useMonacoContext();
-    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 = 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(() => {
-        if (!sdk?.ws || !sdk?.profile || !userId) {
-            setSubscribed(false);
-            return;
-        }
-        setMovements([]);
-        setError(null);
-        setLoading(true);
-        // Fetch initial movements via REST API, then subscribe to WebSocket updates
-        let unsubscribe;
-        sdk.profile
-            .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
-            // Deduplicate by id, preferring latest_movements (newer data)
-            const latestMovements = (response.latest_movements || []).map((m) => ledgerMovementToEvent(m, userId));
-            const historicalMovements = response.movements.map((m) => ledgerMovementToEvent(m, userId));
-            // Merge: latest_movements first, then historical, deduplicated by id
-            const seenIds = new Set();
-            const mergedMovements = [];
-            for (const movement of [...latestMovements, ...historicalMovements]) {
-                if (!seenIds.has(movement.data.id)) {
-                    seenIds.add(movement.data.id);
-                    mergedMovements.push(movement);
-                }
-            }
-            setMovements(mergedMovements.slice(0, sliceSize));
-            // Subscribe to WebSocket movement updates after initial data is loaded
-            // This prevents race conditions where WS events could be overwritten by REST response
-            try {
-                unsubscribe = sdk.ws.movements((event) => {
-                    setMovements((prev) => {
-                        // Deduplicate by id and keep newest first
-                        const exists = prev.some((movement) => movement.data.id === event.data.id);
-                        if (exists) {
-                            // Update existing movement
-                            return prev.map((movement) => (movement.data.id === event.data.id ? event : movement));
-                        }
-                        return [event, ...prev].slice(0, sliceSize);
-                    });
-                });
-                setSubscribed(true);
-            }
-            catch (err) {
-                setError(err instanceof Error ? err : new Error(String(err)));
-                setSubscribed(false);
-            }
-        })
-            .catch((err) => setError(err instanceof Error ? err : new Error(String(err))))
-            .finally(() => setLoading(false));
-        return () => {
-            unsubscribe?.();
-            setSubscribed(false);
-        };
-    }, [sdk?.ws, sdk?.profile, userId, sliceSize, requestLimit, entry_type, transaction_type, asset_id]);
-    return { movements, loading, subscribed, error, clearError };
-}

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

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

package/dist/hooks/useUserOrders/index.js

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

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

@@ -1,18 +0,0 @@
-import type { Order } from "@0xmonaco/types";
-/**
- * Return type for the useUserOrders hook
- */
-export interface UseUserOrdersReturn {
-    /** Array of user orders (merged from REST API and WebSocket updates) */
-    orders: Order[];
-    /** Whether initial data is being loaded */
-    loading: boolean;
-    /** Whether currently subscribed to orders channel */
-    subscribed: boolean;
-    /** Any error that occurred during connection or subscription */
-    error: Error | null;
-    /** Clear the current error state */
-    clearError: () => void;
-    /** Manually refresh orders from REST API */
-    refresh: () => Promise<void>;
-}

package/dist/hooks/useUserOrders/useUserOrders.d.ts

@@ -1,11 +0,0 @@
-import type { UseUserOrdersReturn } from "./types";
-/**
- * Hook for subscribing to real-time user order events via WebSocket (authenticated)
- *
- * Fetches initial orders from the REST API, then subscribes to real-time updates.
- * Requires authentication - the user must be logged in with a valid JWT token.
- * User is identified on the backend via the JWT token.
- *
- * @param maxOrders - Maximum number of orders to keep in state (default: 50)
- */
-export declare function useUserOrders(maxOrders?: number): UseUserOrdersReturn;