@0xmonaco/react 0.7.7 → 0.7.9

package/dist/hooks/useUserOrders/useUserOrders.js

@@ -0,0 +1,191 @@
+import { useCallback, useEffect, useState } from "react";
+import { useMonacoSDK } from "../useMonaco";
+/**
+ * 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 function useUserOrders(maxOrders = 50) {
+    const { sdk } = useMonacoSDK();
+    const [orders, setOrders] = useState([]);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [subscribed, setSubscribed] = useState(false);
+    const clearError = useCallback(() => setError(null), []);
+    const fetchOrders = useCallback(async () => {
+        if (!sdk?.trading)
+            return;
+        setLoading(true);
+        try {
+            const response = await sdk.trading.getPaginatedOrders({
+                page: 1,
+                page_size: maxOrders,
+            });
+            // Combine latest_orders (from Redis) with orders (from PostgreSQL)
+            // latest_orders contains real-time data that may not yet be in PostgreSQL
+            // Deduplicate by id, preferring latest_orders (newer data)
+            const latestOrders = response.latest_orders || [];
+            const historicalOrders = response.orders;
+            // Merge: latest_orders first, then historical, deduplicated by id
+            const seenIds = new Set();
+            const mergedOrders = [];
+            for (const order of [...latestOrders, ...historicalOrders]) {
+                if (!seenIds.has(order.id)) {
+                    seenIds.add(order.id);
+                    mergedOrders.push(order);
+                }
+            }
+            setOrders(mergedOrders.slice(0, maxOrders));
+        }
+        catch (err) {
+            setError(err instanceof Error ? err : new Error(String(err)));
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [sdk?.trading, maxOrders]);
+    // Manual refresh function
+    const refresh = useCallback(async () => {
+        await fetchOrders();
+    }, [fetchOrders]);
+    useEffect(() => {
+        if (!sdk?.ws || !sdk?.trading) {
+            setSubscribed(false);
+            return;
+        }
+        setOrders([]);
+        setError(null);
+        setLoading(true);
+        const limit = Number.isFinite(maxOrders) ? maxOrders : 50;
+        // Fetch initial orders via REST API, then subscribe to WebSocket updates
+        let unsubscribe;
+        fetchOrders()
+            .then(() => {
+            // Subscribe to WebSocket order updates after initial data is loaded
+            // This prevents race conditions where WS events could be overwritten by REST response
+            try {
+                unsubscribe = sdk.ws.userOrders((event) => {
+                    setOrders((prev) => {
+                        const orderId = event.orderId;
+                        // Check if this order already exists
+                        const existingIndex = prev.findIndex((o) => o.id === orderId);
+                        const existingOrder = prev[existingIndex];
+                        if (existingIndex >= 0 && existingOrder) {
+                            // Update existing order with new data from event
+                            const updatedOrder = updateOrderFromEvent(existingOrder, event);
+                            // If order is terminal (filled, canceled, rejected, expired), keep it but update
+                            const newOrders = [...prev];
+                            newOrders[existingIndex] = updatedOrder;
+                            return newOrders;
+                        }
+                        // New order - add to the beginning if it's an OrderPlaced event
+                        if (event.eventType === "OrderPlaced") {
+                            const newOrder = orderFromEvent(event);
+                            if (newOrder) {
+                                return [newOrder, ...prev].slice(0, limit);
+                            }
+                        }
+                        return prev;
+                    });
+                });
+                setSubscribed(true);
+            }
+            catch (err) {
+                setError(err instanceof Error ? err : new Error(String(err)));
+                setSubscribed(false);
+                setLoading(false);
+            }
+        })
+            .catch((err) => {
+            setError(err instanceof Error ? err : new Error(String(err)));
+            setLoading(false);
+        });
+        return () => {
+            unsubscribe?.();
+            setSubscribed(false);
+        };
+    }, [sdk?.ws, sdk?.trading, maxOrders, fetchOrders]);
+    return { orders, loading, subscribed, error, clearError, refresh };
+}
+/**
+ * Create an Order object from an OrderPlaced event
+ */
+function orderFromEvent(event) {
+    if (event.eventType !== "OrderPlaced")
+        return null;
+    const { data } = event;
+    const tradingPairId = data.tradingPairId || data.symbol;
+    if (!tradingPairId)
+        return null;
+    return {
+        id: event.orderId,
+        trading_pair_id: tradingPairId,
+        order_type: (data.orderType || "LIMIT"),
+        side: (data.side || "BUY"),
+        price: data.price,
+        quantity: data.quantity || "0",
+        filled_quantity: "0",
+        average_fill_price: undefined,
+        status: data.status,
+        trading_mode: (data.tradingMode || "SPOT"),
+        time_in_force: data.timeInForce,
+        created_at: event.timestamp,
+        updated_at: event.timestamp,
+    };
+}
+/**
+ * Update an existing Order with data from a WebSocket event
+ */
+function updateOrderFromEvent(order, event) {
+    const data = event.data;
+    // Prefer status from event data when available, fall back to event-type-based mapping
+    let newStatus = order.status;
+    if ("status" in data && data.status) {
+        newStatus = data.status;
+    }
+    else {
+        switch (event.eventType) {
+            case "OrderPlaced":
+                newStatus = "SUBMITTED";
+                break;
+            case "OrderPartiallyFilled":
+                newStatus = "PARTIALLY_FILLED";
+                break;
+            case "OrderFilled":
+                newStatus = "FILLED";
+                break;
+            case "OrderCancelled":
+                newStatus = "CANCELLED";
+                break;
+            case "OrderRejected":
+                newStatus = "REJECTED";
+                break;
+            case "OrderExpired":
+                newStatus = "EXPIRED";
+                break;
+        }
+    }
+    // Get filled quantity from different event types
+    let filledQuantity = order.filled_quantity;
+    let avgFillPrice = order.average_fill_price;
+    if ("totalFilled" in data && data.totalFilled) {
+        filledQuantity = data.totalFilled;
+    }
+    if ("filledQuantity" in data && data.filledQuantity) {
+        filledQuantity = data.filledQuantity;
+    }
+    if ("averageFillPrice" in data && data.averageFillPrice) {
+        avgFillPrice = data.averageFillPrice;
+    }
+    return {
+        ...order,
+        status: newStatus,
+        filled_quantity: filledQuantity,
+        average_fill_price: avgFillPrice,
+        updated_at: event.timestamp,
+    };
+}

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

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

package/dist/hooks/useVault/index.js

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

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

@@ -0,0 +1,15 @@
+import type { TransactionResult, WithdrawResult } from "@0xmonaco/types";
+export interface UseVaultReturn {
+    /** Approve the vault to spend tokens */
+    approve: (assetId: string, amount: bigint, autoWait?: boolean) => Promise<TransactionResult>;
+    /** Deposit tokens into the vault */
+    deposit: (assetId: string, amount: bigint, autoWait?: boolean) => Promise<TransactionResult>;
+    /** Initiate a withdrawal and submit the pre-signed calldata on-chain */
+    withdraw: (assetId: string, amount: bigint, autoWait?: boolean) => Promise<WithdrawResult>;
+    /** Retry a withdrawal whose on-chain submission never landed — does NOT create a new one */
+    retryWithdrawal: (withdrawalIndex: number, autoWait?: boolean) => Promise<WithdrawResult>;
+    /** Get the allowance for a token */
+    getAllowance: (assetId: string) => Promise<bigint>;
+    /** Check if a token needs approval for an amount */
+    needsApproval: (assetId: string, amount: bigint) => Promise<boolean>;
+}

package/dist/hooks/useVault/useVault.d.ts

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

package/dist/hooks/useVault/useVault.js

@@ -0,0 +1,66 @@
+import { useCallback } from "react";
+import { useMonacoSDK } from "../useMonaco";
+export const useVault = () => {
+    const { sdk } = useMonacoSDK();
+    const approve = useCallback(async (assetId, amount, autoWait) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        if (!assetId?.trim())
+            throw new Error("Asset ID is required and cannot be empty");
+        if (amount <= 0n)
+            throw new Error("Amount must be greater than 0");
+        return await sdk.vault.approve(assetId, amount, autoWait);
+    }, [sdk]);
+    const deposit = useCallback(async (assetId, amount, autoWait) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        if (!assetId?.trim())
+            throw new Error("Asset ID is required and cannot be empty");
+        if (amount <= 0n)
+            throw new Error("Amount must be greater than 0");
+        return await sdk.vault.deposit(assetId, amount, autoWait);
+    }, [sdk]);
+    const withdraw = useCallback(async (assetId, amount, autoWait) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        if (!assetId?.trim())
+            throw new Error("Asset ID is required and cannot be empty");
+        if (amount <= 0n)
+            throw new Error("Amount must be greater than 0");
+        return await sdk.vault.withdraw(assetId, amount, autoWait);
+    }, [sdk]);
+    const retryWithdrawal = useCallback(async (withdrawalIndex, autoWait) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        if (!Number.isInteger(withdrawalIndex) || withdrawalIndex < 0) {
+            throw new Error("withdrawalIndex must be a non-negative integer");
+        }
+        return await sdk.vault.retryWithdrawal(withdrawalIndex, autoWait);
+    }, [sdk]);
+    const getAllowance = useCallback(async (assetId) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        if (!assetId?.trim())
+            throw new Error("Asset ID is required and cannot be empty");
+        return await sdk.vault.getAllowance(assetId);
+    }, [sdk]);
+    const needsApproval = useCallback(async (assetId, amount) => {
+        if (!sdk)
+            throw new Error("SDK not available");
+        if (!assetId?.trim())
+            throw new Error("Asset ID is required and cannot be empty");
+        if (amount <= 0n)
+            throw new Error("Amount must be greater than 0");
+        return await sdk.vault.needsApproval(assetId, amount);
+    }, [sdk]);
+    return {
+        // Token operations
+        approve,
+        deposit,
+        withdraw,
+        retryWithdrawal,
+        // Approval and allowance queries
+        getAllowance,
+        needsApproval,
+    };
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./hooks";
+export * from "./provider";
+export * from "./utils";

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./hooks";
+export * from "./provider";
+export * from "./utils";

package/dist/provider/MonacoProvider.d.ts

@@ -0,0 +1,3 @@
+import { type MonacoContextValue, type MonacoProviderProps } from "./types";
+export declare const MonacoProvider: ({ children, clientId, network, seiRpcUrl, walletClient, tokenLifecycle: tokenLifecycleConfig }: MonacoProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useMonacoContext: () => MonacoContextValue;

package/dist/provider/MonacoProvider.js

@@ -0,0 +1,142 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { MonacoSDK } from "@0xmonaco/core";
+import { createContext, useContext, useEffect, useMemo, useRef, useState } from "react";
+import { useTokenLifecycle } from "../hooks";
+import { clearAuthState, loadAuthState } from "../utils";
+import { TradeFeedProvider } from "./TradeFeedProvider";
+import { AuthenticationStatus } from "./types";
+const MonacoContext = createContext(null);
+const normalizeUrl = (url) => {
+    try {
+        const parsed = new URL(url);
+        return parsed.href.replace(/\/$/, '');
+    }
+    catch {
+        return url;
+    }
+};
+export const MonacoProvider = ({ children, clientId, network, seiRpcUrl, walletClient, tokenLifecycle: tokenLifecycleConfig }) => {
+    const [sdk, setSdk] = useState(null);
+    const [error, setError] = useState(null);
+    // Track previous network config to detect actual changes vs initial mount
+    const prevNetworkRef = useRef(null);
+    // Global authentication state (shared across all components)
+    const [authenticationStatus, setAuthenticationStatus] = useState(AuthenticationStatus.UNAUTHENTICATED);
+    // Token lifecycle management
+    const tokenLifecycle = useTokenLifecycle(sdk, tokenLifecycleConfig);
+    // Ref to access tokenLifecycle.clearTokens without adding it to effect dependencies
+    // (tokenLifecycle depends on sdk, which would cause a circular dependency)
+    const tokenLifecycleRef = useRef(tokenLifecycle);
+    useEffect(() => {
+        tokenLifecycleRef.current = tokenLifecycle;
+    }, [tokenLifecycle]);
+    // Initialize SDK without wallet (for public APIs)
+    useEffect(() => {
+        const prevNetwork = prevNetworkRef.current;
+        const networkChanged = prevNetwork !== null && (prevNetwork.network !== network ||
+            normalizeUrl(prevNetwork.seiRpcUrl) !== normalizeUrl(seiRpcUrl));
+        // Only reset auth state when network actually changes, not on initial mount
+        if (networkChanged) {
+            setAuthenticationStatus(AuthenticationStatus.UNAUTHENTICATED);
+            tokenLifecycleRef.current.clearTokens(); // stop auto-refresh and drop in-memory secrets
+            clearAuthState();
+        }
+        try {
+            setError(null);
+            const sdkConfig = {
+                network,
+                seiRpcUrl,
+            };
+            const newSdk = new MonacoSDK(sdkConfig);
+            setSdk(newSdk);
+            // Update ref only after successful SDK creation
+            prevNetworkRef.current = { network, seiRpcUrl };
+        }
+        catch (err) {
+            const normalizedError = err instanceof Error ? err : new Error(String(err));
+            setSdk(null);
+            setError(normalizedError);
+        }
+    }, [network, seiRpcUrl]);
+    // Cleanup: disconnect WebSocket when SDK changes or unmounts
+    useEffect(() => {
+        return () => {
+            sdk?.ws.disconnect();
+        };
+    }, [sdk]);
+    // Update wallet client when it changes or when SDK is recreated (e.g., network change)
+    useEffect(() => {
+        if (!sdk || !walletClient)
+            return;
+        try {
+            sdk.setWalletClient(walletClient);
+        }
+        catch (err) {
+            const normalizedError = err instanceof Error ? err : new Error(String(err));
+            setError(normalizedError);
+        }
+    }, [sdk, walletClient]);
+    // Restore cached tokens when SDK changes (including on mount)
+    useEffect(() => {
+        if (!sdk)
+            return;
+        const persistTokens = tokenLifecycleConfig?.persistTokens ?? true;
+        if (!persistTokens)
+            return;
+        const cachedAuthState = loadAuthState();
+        if (!cachedAuthState)
+            return;
+        // Check if the token is expired
+        if (tokenLifecycle.isTokenExpired(cachedAuthState)) {
+            // Set the auth state first so refreshAuth has a refresh token to use
+            sdk.setAuthState(cachedAuthState);
+            tokenLifecycle.initializeTokens(cachedAuthState);
+            // Attempt to refresh
+            tokenLifecycle.refreshTokens().then((newAuthState) => {
+                if (newAuthState) {
+                    // Refresh succeeded, SDK auth state is already updated by refreshAuth
+                    setAuthenticationStatus(AuthenticationStatus.AUTHENTICATED);
+                }
+                else {
+                    // Refresh failed, clear tokens and SDK state
+                    tokenLifecycle.clearTokens();
+                    sdk.logout().catch(() => { }); // Ignore errors, we're already in cleanup mode
+                    setAuthenticationStatus(AuthenticationStatus.UNAUTHENTICATED);
+                }
+            }).catch((err) => {
+                const normalizedError = err instanceof Error ? err : new Error(String(err));
+                setError(normalizedError);
+                tokenLifecycle.clearTokens();
+                sdk.logout().catch(() => { }); // Ignore errors, we're already in cleanup mode
+                setAuthenticationStatus(AuthenticationStatus.UNAUTHENTICATED);
+            });
+        }
+        else {
+            // Token is still valid, restore it
+            sdk.setAuthState(cachedAuthState);
+            tokenLifecycle.initializeTokens(cachedAuthState);
+            setAuthenticationStatus(AuthenticationStatus.AUTHENTICATED);
+        }
+    }, [sdk, tokenLifecycle, tokenLifecycleConfig?.persistTokens]);
+    const contextValue = useMemo(() => ({
+        sdk,
+        clientId,
+        isWalletConnected: !!walletClient,
+        error,
+        // Global authentication state
+        authenticationStatus,
+        // Token lifecycle management
+        tokenLifecycle,
+        // Global authentication state setters
+        setAuthenticationStatus,
+        setError,
+    }), [sdk, clientId, walletClient, error, authenticationStatus, tokenLifecycle]);
+    return (_jsx(MonacoContext.Provider, { value: contextValue, children: _jsx(TradeFeedProvider, { children: children }) }));
+};
+export const useMonacoContext = () => {
+    const context = useContext(MonacoContext);
+    if (!context) {
+        throw new Error("useMonacoContext must be used within a MonacoProvider. " + "Make sure to wrap your app with <MonacoProvider>.");
+    }
+    return context;
+};

package/dist/provider/TradeFeedProvider.d.ts

@@ -0,0 +1,22 @@
+import type { TradeEvent } from "@0xmonaco/types";
+import type { ReactNode } from "react";
+export declare const MAX_TRADES = 50;
+export interface TradeFeedSubscription {
+    trades: TradeEvent[];
+    error: Error | null;
+    subscribed: boolean;
+    subscriberCount: number;
+    fetchingInitialState: boolean;
+}
+interface TradeFeedContextValue {
+    /** Subscribe to a trading pair - returns unsubscribe function */
+    subscribe: (tradingPairId: string, fetchInitialTrades: () => Promise<TradeEvent[]>, subscribeToWs: (handler: (event: TradeEvent) => void) => () => void) => () => void;
+    /** Get subscription state with reactivity */
+    subscriptions: Map<string, TradeFeedSubscription>;
+}
+interface TradeFeedProviderProps {
+    children: ReactNode;
+}
+export declare const TradeFeedProvider: ({ children }: TradeFeedProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useTradeFeedContext: () => TradeFeedContextValue;
+export {};

package/dist/provider/TradeFeedProvider.js

@@ -0,0 +1,143 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+export const MAX_TRADES = 50;
+const TradeFeedContext = createContext(null);
+export const TradeFeedProvider = ({ children }) => {
+    const [subscriptions, setSubscriptions] = useState(new Map());
+    // Track active WebSocket unsubscribe functions
+    const wsUnsubscribes = useRef(new Map());
+    // Cleanup all WebSocket subscriptions when provider unmounts
+    useEffect(() => {
+        return () => {
+            for (const unsubscribe of wsUnsubscribes.current.values()) {
+                unsubscribe();
+            }
+            wsUnsubscribes.current.clear();
+        };
+    }, []);
+    const handleTrade = useCallback((tradingPairId, event) => {
+        setSubscriptions((prev) => {
+            const current = prev.get(tradingPairId);
+            if (!current)
+                return prev;
+            const exists = current.trades.some((t) => t.data.tradeId === event.data.tradeId);
+            if (exists)
+                return prev;
+            const newSubscriptions = new Map(prev);
+            newSubscriptions.set(tradingPairId, {
+                ...current,
+                trades: [event, ...current.trades].slice(0, MAX_TRADES),
+                error: null, // Clear error on successful WebSocket event
+            });
+            return newSubscriptions;
+        });
+    }, []);
+    // Use ref to maintain stable reference to handleTrade for the subscribe callback
+    const handleTradeRef = useRef(handleTrade);
+    useEffect(() => {
+        handleTradeRef.current = handleTrade;
+    });
+    const subscribe = useCallback((tradingPairId, fetchInitialTrades, subscribeToWs) => {
+        setSubscriptions((prev) => {
+            const current = prev.get(tradingPairId);
+            if (current) {
+                // Already subscribed, just increment count
+                const newSubscriptions = new Map(prev);
+                newSubscriptions.set(tradingPairId, {
+                    ...current,
+                    subscriberCount: current.subscriberCount + 1,
+                });
+                return newSubscriptions;
+            }
+            // First subscriber - create new subscription
+            const newSubscriptions = new Map(prev);
+            newSubscriptions.set(tradingPairId, {
+                trades: [],
+                error: null,
+                subscribed: true,
+                subscriberCount: 1,
+                fetchingInitialState: true,
+            });
+            return newSubscriptions;
+        });
+        // Check if this is the first subscriber (no existing WS subscription)
+        if (!wsUnsubscribes.current.has(tradingPairId)) {
+            // Set placeholder immediately to prevent race condition with concurrent subscribers
+            wsUnsubscribes.current.set(tradingPairId, () => { });
+            // Fetch initial trades
+            fetchInitialTrades()
+                .then((initialTrades) => {
+                setSubscriptions((prev) => {
+                    const current = prev.get(tradingPairId);
+                    if (!current)
+                        return prev;
+                    const newSubscriptions = new Map(prev);
+                    newSubscriptions.set(tradingPairId, {
+                        ...current,
+                        trades: initialTrades.slice(0, MAX_TRADES),
+                        error: null,
+                        fetchingInitialState: false,
+                    });
+                    return newSubscriptions;
+                });
+            })
+                .catch((err) => {
+                setSubscriptions((prev) => {
+                    const current = prev.get(tradingPairId);
+                    if (!current)
+                        return prev;
+                    const newSubscriptions = new Map(prev);
+                    newSubscriptions.set(tradingPairId, {
+                        ...current,
+                        error: err instanceof Error ? err : new Error(String(err)),
+                        fetchingInitialState: false,
+                    });
+                    return newSubscriptions;
+                });
+            });
+            // Subscribe to WebSocket
+            const unsubscribe = subscribeToWs((event) => handleTradeRef.current(tradingPairId, event));
+            wsUnsubscribes.current.set(tradingPairId, unsubscribe);
+        }
+        // Return unsubscribe function
+        return () => {
+            setSubscriptions((prev) => {
+                const current = prev.get(tradingPairId);
+                if (!current)
+                    return prev;
+                const newCount = current.subscriberCount - 1;
+                if (newCount <= 0) {
+                    // Last subscriber - clean up
+                    const wsUnsubscribe = wsUnsubscribes.current.get(tradingPairId);
+                    if (wsUnsubscribe) {
+                        wsUnsubscribe();
+                        wsUnsubscribes.current.delete(tradingPairId);
+                    }
+                    const newSubscriptions = new Map(prev);
+                    newSubscriptions.delete(tradingPairId);
+                    return newSubscriptions;
+                }
+                // Still have subscribers, just decrement count
+                const newSubscriptions = new Map(prev);
+                newSubscriptions.set(tradingPairId, {
+                    ...current,
+                    subscriberCount: newCount,
+                });
+                return newSubscriptions;
+            });
+        };
+    }, []);
+    const contextValue = useMemo(() => ({
+        subscribe,
+        subscriptions,
+    }), [subscribe, subscriptions]);
+    return _jsx(TradeFeedContext.Provider, { value: contextValue, children: children });
+};
+export const useTradeFeedContext = () => {
+    const context = useContext(TradeFeedContext);
+    if (!context) {
+        throw new Error("useTradeFeedContext must be used within a TradeFeedProvider. " +
+            "Make sure to wrap your app with <MonacoProvider>.");
+    }
+    return context;
+};

package/dist/provider/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./MonacoProvider";
+export { MAX_TRADES, TradeFeedProvider, type TradeFeedSubscription, useTradeFeedContext } from "./TradeFeedProvider";
+export * from "./types";

package/dist/provider/index.js

@@ -0,0 +1,3 @@
+export * from "./MonacoProvider";
+export { MAX_TRADES, TradeFeedProvider, useTradeFeedContext } from "./TradeFeedProvider";
+export * from "./types";

package/dist/provider/types.d.ts

@@ -0,0 +1,49 @@
+import type { MonacoSDK, Network } from "@0xmonaco/types";
+import type { ReactNode } from "react";
+import type { WalletClient } from "viem";
+import type { TokenLifecycleConfig, UseTokenLifecycleReturn } from "../hooks";
+export declare enum AuthenticationStatus {
+    /** User is not authenticated */
+    UNAUTHENTICATED = "unauthenticated",
+    /** Authentication is in progress */
+    AUTHENTICATING = "authenticating",
+    /** User is successfully authenticated */
+    AUTHENTICATED = "authenticated"
+}
+export interface MonacoContextValue {
+    /** Monaco SDK instance */
+    sdk: MonacoSDK | null;
+    /** Client ID for authentication */
+    clientId: string;
+    /** Whether a wallet client is connected */
+    isWalletConnected: boolean;
+    /** Any error that occurred (SDK initialization, authentication, etc.) */
+    error: Error | null;
+    /** Current authentication status */
+    authenticationStatus: AuthenticationStatus;
+    /** Token lifecycle manager */
+    tokenLifecycle: UseTokenLifecycleReturn;
+    /** Function to update authentication status */
+    setAuthenticationStatus: (status: AuthenticationStatus) => void;
+    /** Function to update error */
+    setError: (error: Error | null) => void;
+}
+export interface MonacoProviderProps {
+    /** Child components */
+    children: ReactNode;
+    /** Client ID for authentication */
+    clientId: string;
+    /**
+     * Network to use. Must be one of: "local", "development", "staging", "mainnet".
+     */
+    network: Network;
+    /** RPC URL for Sei blockchain interactions */
+    seiRpcUrl: string;
+    /**
+     * Optional wallet client for authenticated operations.
+     * Can be obtained from wagmi, RainbowKit, ConnectKit, or any viem-compatible wallet provider.
+     */
+    walletClient?: WalletClient;
+    /** Token lifecycle configuration options */
+    tokenLifecycle?: TokenLifecycleConfig;
+}