@luxfi/dex 1.3.0 → 2.0.0

package/dist/hooks/index.d.ts

@@ -1,7 +1,22 @@
 /**
- * DEX Hooks Exports
+ * LX Hooks Exports
  * React hooks for DEX integration
+ *
+ * AMM (LP-9010):
+ * - useQuote, useSwap
+ *
+ * CLOB (LP-9020):
+ * - useLXBookL1, useLXBookPlaceOrder, useLXBookCancelOrder
+ *
+ * Vault (LP-9030):
+ * - useLXVault, useLXVaultPosition, useLXVaultMargin
+ *
+ * Feeds (LP-9040):
+ * - useLXFeedMarkPrice, useLXFeedFundingRate, useLXMarketPrices
  */
 export * from './use-quote';
 export * from './use-swap';
+export * from './use-lxbook';
+export * from './use-lxvault';
+export * from './use-lxfeed';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAG1B,cAAc,cAAc,CAAA;AAG5B,cAAc,eAAe,CAAA;AAG7B,cAAc,cAAc,CAAA"}

package/dist/hooks/index.js

@@ -1,6 +1,25 @@
 /**
- * DEX Hooks Exports
+ * LX Hooks Exports
  * React hooks for DEX integration
+ *
+ * AMM (LP-9010):
+ * - useQuote, useSwap
+ *
+ * CLOB (LP-9020):
+ * - useLXBookL1, useLXBookPlaceOrder, useLXBookCancelOrder
+ *
+ * Vault (LP-9030):
+ * - useLXVault, useLXVaultPosition, useLXVaultMargin
+ *
+ * Feeds (LP-9040):
+ * - useLXFeedMarkPrice, useLXFeedFundingRate, useLXMarketPrices
  */
+// AMM hooks
 export * from './use-quote';
 export * from './use-swap';
+// LXBook hooks (LP-9020) - CLOB trading
+export * from './use-lxbook';
+// LXVault hooks (LP-9030) - Custody and margin
+export * from './use-lxvault';
+// LXFeed hooks (LP-9040) - Price feeds
+export * from './use-lxfeed';

package/dist/hooks/use-lxbook.d.ts

@@ -0,0 +1,95 @@
+import { type LXAction, type LXL1, TIF } from '../precompile/types';
+/**
+ * Hook to get L1 (best bid/ask) for a market
+ */
+export declare function useLXBookL1(marketId: number): {
+    l1: LXL1 | undefined;
+    isLoading: boolean;
+    error: import("viem").ReadContractErrorType | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<{
+        bestBidPxX18: bigint;
+        bestBidSzX18: bigint;
+        bestAskPxX18: bigint;
+        bestAskSzX18: bigint;
+        lastTradePxX18: bigint;
+    }, import("viem").ReadContractErrorType>>;
+};
+/**
+ * Hook to get market config
+ */
+export declare function useLXBookMarket(marketId: number): {
+    config: {
+        baseAsset: `0x${string}`;
+        quoteAsset: `0x${string}`;
+        tickSizeX18: bigint;
+        lotSizeX18: bigint;
+        makerFeePpm: number;
+        takerFeePpm: number;
+        feedId: `0x${string}`;
+        initialStatus: number;
+    } | undefined;
+    isLoading: boolean;
+    error: import("viem").ReadContractErrorType | null;
+};
+/**
+ * Hook to get market status
+ */
+export declare function useLXBookMarketStatus(marketId: number): {
+    status: number | undefined;
+    isLoading: boolean;
+    error: import("viem").ReadContractErrorType | null;
+};
+interface UseLXBookExecuteResult {
+    execute: (action: LXAction) => void;
+    executeBatch: (actions: LXAction[]) => void;
+    hash: `0x${string}` | undefined;
+    isPending: boolean;
+    isConfirming: boolean;
+    isSuccess: boolean;
+    error: Error | null;
+}
+/**
+ * Hook for placing orders via LXBook execute()
+ */
+export declare function useLXBookExecute(): UseLXBookExecuteResult;
+interface UseLXBookPlaceOrderResult {
+    placeOrder: (params: {
+        marketId: number;
+        isBuy: boolean;
+        size: bigint;
+        price: bigint;
+        tif?: TIF;
+        reduceOnly?: boolean;
+        cloid?: `0x${string}`;
+    }) => void;
+    placeMarketOrder: (params: {
+        marketId: number;
+        isBuy: boolean;
+        size: bigint;
+        reduceOnly?: boolean;
+    }) => void;
+    hash: `0x${string}` | undefined;
+    isPending: boolean;
+    isConfirming: boolean;
+    isSuccess: boolean;
+    error: Error | null;
+}
+/**
+ * Hook for placing limit orders
+ */
+export declare function useLXBookPlaceOrder(): UseLXBookPlaceOrderResult;
+interface UseLXBookCancelOrderResult {
+    cancelByOid: (oid: bigint) => void;
+    cancelByCloid: (cloid: `0x${string}`) => void;
+    hash: `0x${string}` | undefined;
+    isPending: boolean;
+    isConfirming: boolean;
+    isSuccess: boolean;
+    error: Error | null;
+}
+/**
+ * Hook for canceling orders
+ */
+export declare function useLXBookCancelOrder(): UseLXBookCancelOrderResult;
+export {};
+//# sourceMappingURL=use-lxbook.d.ts.map

package/dist/hooks/use-lxbook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-lxbook.d.ts","sourceRoot":"","sources":["../../src/hooks/use-lxbook.ts"],"names":[],"mappings":"AAUA,OAAO,EAEL,KAAK,QAAQ,EAEb,KAAK,IAAI,EAET,GAAG,EAEJ,MAAM,qBAAqB,CAAA;AAE5B;;GAEG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM;QAS5B,IAAI,GAAG,SAAS;;;;;;;;;;EAK/B;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM;;;;;;;;;;;;;EAa/C;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM;YASlC,MAAM,GAAG,SAAS;;;EAIrC;AAuDD,UAAU,sBAAsB;IAC9B,OAAO,EAAE,CAAC,MAAM,EAAE,QAAQ,KAAK,IAAI,CAAA;IACnC,YAAY,EAAE,CAAC,OAAO,EAAE,QAAQ,EAAE,KAAK,IAAI,CAAA;IAC3C,IAAI,EAAE,KAAK,MAAM,EAAE,GAAG,SAAS,CAAA;IAC/B,SAAS,EAAE,OAAO,CAAA;IAClB,YAAY,EAAE,OAAO,CAAA;IACrB,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;CACpB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,sBAAsB,CAqCzD;AAED,UAAU,yBAAyB;IACjC,UAAU,EAAE,CAAC,MAAM,EAAE;QACnB,QAAQ,EAAE,MAAM,CAAA;QAChB,KAAK,EAAE,OAAO,CAAA;QACd,IAAI,EAAE,MAAM,CAAA;QACZ,KAAK,EAAE,MAAM,CAAA;QACb,GAAG,CAAC,EAAE,GAAG,CAAA;QACT,UAAU,CAAC,EAAE,OAAO,CAAA;QACpB,KAAK,CAAC,EAAE,KAAK,MAAM,EAAE,CAAA;KACtB,KAAK,IAAI,CAAA;IACV,gBAAgB,EAAE,CAAC,MAAM,EAAE;QACzB,QAAQ,EAAE,MAAM,CAAA;QAChB,KAAK,EAAE,OAAO,CAAA;QACd,IAAI,EAAE,MAAM,CAAA;QACZ,UAAU,CAAC,EAAE,OAAO,CAAA;KACrB,KAAK,IAAI,CAAA;IACV,IAAI,EAAE,KAAK,MAAM,EAAE,GAAG,SAAS,CAAA;IAC/B,SAAS,EAAE,OAAO,CAAA;IAClB,YAAY,EAAE,OAAO,CAAA;IACrB,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;CACpB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,yBAAyB,CAiF/D;AAED,UAAU,0BAA0B;IAClC,WAAW,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;IAClC,aAAa,EAAE,CAAC,KAAK,EAAE,KAAK,MAAM,EAAE,KAAK,IAAI,CAAA;IAC7C,IAAI,EAAE,KAAK,MAAM,EAAE,GAAG,SAAS,CAAA;IAC/B,SAAS,EAAE,OAAO,CAAA;IAClB,YAAY,EAAE,OAAO,CAAA;IACrB,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;CACpB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,0BAA0B,CAwCjE"}

package/dist/hooks/use-lxbook.js

@@ -0,0 +1,213 @@
+/**
+ * LXBook Hooks (LP-9020)
+ * React hooks for CLOB trading via LXBook precompile
+ */
+import { useCallback } from 'react';
+import { useReadContract, useWriteContract, useWaitForTransactionReceipt } from 'wagmi';
+import { encodeFunctionData } from 'viem';
+import { LX } from '../precompile/addresses';
+import { LX_BOOK_ABI } from '../precompile/abis';
+import { ActionType, TIF, OrderKind, } from '../precompile/types';
+/**
+ * Hook to get L1 (best bid/ask) for a market
+ */
+export function useLXBookL1(marketId) {
+    const { data, isLoading, error, refetch } = useReadContract({
+        address: LX.LX_BOOK,
+        abi: LX_BOOK_ABI,
+        functionName: 'getL1',
+        args: [marketId],
+    });
+    return {
+        l1: data,
+        isLoading,
+        error,
+        refetch,
+    };
+}
+/**
+ * Hook to get market config
+ */
+export function useLXBookMarket(marketId) {
+    const { data, isLoading, error } = useReadContract({
+        address: LX.LX_BOOK,
+        abi: LX_BOOK_ABI,
+        functionName: 'getMarketConfig',
+        args: [marketId],
+    });
+    return {
+        config: data,
+        isLoading,
+        error,
+    };
+}
+/**
+ * Hook to get market status
+ */
+export function useLXBookMarketStatus(marketId) {
+    const { data, isLoading, error } = useReadContract({
+        address: LX.LX_BOOK,
+        abi: LX_BOOK_ABI,
+        functionName: 'getMarketStatus',
+        args: [marketId],
+    });
+    return {
+        status: data,
+        isLoading,
+        error,
+    };
+}
+/**
+ * Build action payload for execute()
+ */
+function buildAction(actionType, nonce, expiresAfter, data) {
+    return {
+        actionType,
+        nonce,
+        expiresAfter,
+        data,
+    };
+}
+/**
+ * Encode order data for placement
+ */
+function encodeOrderData(order) {
+    // Pack order into bytes - this matches the Go/Solidity struct layout
+    const encoded = encodeFunctionData({
+        abi: [{
+                type: 'function',
+                name: 'encodeOrder',
+                inputs: [{
+                        name: 'order',
+                        type: 'tuple',
+                        components: [
+                            { name: 'marketId', type: 'uint32' },
+                            { name: 'isBuy', type: 'bool' },
+                            { name: 'kind', type: 'uint8' },
+                            { name: 'sizeX18', type: 'uint128' },
+                            { name: 'limitPxX18', type: 'uint128' },
+                            { name: 'triggerPxX18', type: 'uint128' },
+                            { name: 'reduceOnly', type: 'bool' },
+                            { name: 'tif', type: 'uint8' },
+                            { name: 'cloid', type: 'bytes16' },
+                            { name: 'groupId', type: 'bytes16' },
+                            { name: 'groupType', type: 'uint8' },
+                        ],
+                    }],
+                outputs: [],
+                stateMutability: 'pure',
+            }],
+        functionName: 'encodeOrder',
+        args: [order],
+    });
+    // Strip function selector (first 4 bytes)
+    return `0x${encoded.slice(10)}`;
+}
+/**
+ * Hook for placing orders via LXBook execute()
+ */
+export function useLXBookExecute() {
+    const { writeContract, data: hash, isPending, error } = useWriteContract();
+    const { isLoading: isConfirming, isSuccess } = useWaitForTransactionReceipt({ hash });
+    const execute = useCallback((action) => {
+        writeContract({
+            address: LX.LX_BOOK,
+            abi: LX_BOOK_ABI,
+            functionName: 'execute',
+            args: [action],
+        });
+    }, [writeContract]);
+    const executeBatch = useCallback((actions) => {
+        writeContract({
+            address: LX.LX_BOOK,
+            abi: LX_BOOK_ABI,
+            functionName: 'executeBatch',
+            args: [actions],
+        });
+    }, [writeContract]);
+    return {
+        execute,
+        executeBatch,
+        hash,
+        isPending,
+        isConfirming,
+        isSuccess,
+        error,
+    };
+}
+/**
+ * Hook for placing limit orders
+ */
+export function useLXBookPlaceOrder() {
+    const { execute, hash, isPending, isConfirming, isSuccess, error } = useLXBookExecute();
+    const placeOrder = useCallback(async (params) => {
+        const order = {
+            marketId: params.marketId,
+            isBuy: params.isBuy,
+            kind: OrderKind.LIMIT,
+            sizeX18: params.size,
+            limitPxX18: params.price,
+            triggerPxX18: 0n,
+            reduceOnly: params.reduceOnly ?? false,
+            tif: params.tif ?? TIF.GTC,
+            cloid: params.cloid ?? '0x00000000000000000000000000000000',
+            groupId: '0x00000000000000000000000000000000',
+            groupType: 0,
+        };
+        const action = buildAction(ActionType.PLACE, BigInt(Date.now()), BigInt(Math.floor(Date.now() / 1000) + 300), // 5 min expiry
+        encodeOrderData(order));
+        return execute(action);
+    }, [execute]);
+    const placeMarketOrder = useCallback(async (params) => {
+        const order = {
+            marketId: params.marketId,
+            isBuy: params.isBuy,
+            kind: OrderKind.MARKET,
+            sizeX18: params.size,
+            limitPxX18: 0n, // Market order - no limit
+            triggerPxX18: 0n,
+            reduceOnly: params.reduceOnly ?? false,
+            tif: TIF.IOC,
+            cloid: '0x00000000000000000000000000000000',
+            groupId: '0x00000000000000000000000000000000',
+            groupType: 0,
+        };
+        const action = buildAction(ActionType.PLACE, BigInt(Date.now()), BigInt(Math.floor(Date.now() / 1000) + 60), // 1 min expiry for market
+        encodeOrderData(order));
+        return execute(action);
+    }, [execute]);
+    return {
+        placeOrder,
+        placeMarketOrder,
+        hash,
+        isPending,
+        isConfirming,
+        isSuccess,
+        error,
+    };
+}
+/**
+ * Hook for canceling orders
+ */
+export function useLXBookCancelOrder() {
+    const { execute, hash, isPending, isConfirming, isSuccess, error } = useLXBookExecute();
+    const cancelByOid = useCallback(async (oid) => {
+        // Encode oid as bytes
+        const data = `0x${oid.toString(16).padStart(64, '0')}`;
+        const action = buildAction(ActionType.CANCEL, BigInt(Date.now()), BigInt(Math.floor(Date.now() / 1000) + 60), data);
+        return execute(action);
+    }, [execute]);
+    const cancelByCloid = useCallback(async (cloid) => {
+        const action = buildAction(ActionType.CANCEL_BY_CLOID, BigInt(Date.now()), BigInt(Math.floor(Date.now() / 1000) + 60), cloid);
+        return execute(action);
+    }, [execute]);
+    return {
+        cancelByOid,
+        cancelByCloid,
+        hash,
+        isPending,
+        isConfirming,
+        isSuccess,
+        error,
+    };
+}

package/dist/hooks/use-lxfeed.d.ts

@@ -0,0 +1,111 @@
+import type { Address } from 'viem';
+import type { LXMarkPrice } from '../precompile/types';
+/**
+ * Hook to get mark price for a market
+ */
+export declare function useLXFeedMarkPrice(marketId: number): {
+    markPrice: LXMarkPrice | undefined;
+    isLoading: boolean;
+    error: import("viem").ReadContractErrorType | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<{
+        indexPxX18: bigint;
+        markPxX18: bigint;
+        premiumX18: bigint;
+        timestamp: bigint;
+    }, import("viem").ReadContractErrorType>>;
+};
+/**
+ * Hook to get index price for a market
+ */
+export declare function useLXFeedIndexPrice(marketId: number): {
+    priceX18: bigint | undefined;
+    timestamp: bigint | undefined;
+    isLoading: boolean;
+    error: import("viem").ReadContractErrorType | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<readonly [bigint, timestamp: bigint], import("viem").ReadContractErrorType>>;
+};
+/**
+ * Hook to get funding rate for a market
+ */
+export declare function useLXFeedFundingRate(marketId: number): {
+    rateX18: bigint | undefined;
+    nextFundingTime: bigint | undefined;
+    isLoading: boolean;
+    error: import("viem").ReadContractErrorType | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<readonly [bigint, bigint], import("viem").ReadContractErrorType>>;
+};
+/**
+ * Hook to get trigger price for stop/take orders
+ */
+export declare function useLXFeedTriggerPrice(marketId: number, isBuy: boolean): {
+    triggerPriceX18: bigint | undefined;
+    isLoading: boolean;
+    error: import("viem").ReadContractErrorType | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<bigint, import("viem").ReadContractErrorType>>;
+};
+/**
+ * Hook to get oracle price for token pair
+ */
+export declare function useLXOraclePrice(baseToken: Address, quoteToken: Address): {
+    price: {
+        price: bigint;
+        confidence: bigint;
+        timestamp: bigint;
+        source: number;
+        expo: number;
+    } | undefined;
+    isLoading: boolean;
+    error: import("viem").ReadContractErrorType | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<{
+        price: bigint;
+        confidence: bigint;
+        timestamp: bigint;
+        source: number;
+        expo: number;
+    }, import("viem").ReadContractErrorType>>;
+};
+/**
+ * Hook to get aggregated oracle price with deviation info
+ */
+export declare function useLXOracleAggregatedPrice(baseToken: Address, quoteToken: Address, maxStaleness?: bigint): {
+    aggregated: {
+        price: bigint;
+        minPrice: bigint;
+        maxPrice: bigint;
+        deviation: bigint;
+        numSources: bigint;
+        timestamp: bigint;
+    } | undefined;
+    isLoading: boolean;
+    error: import("viem").ReadContractErrorType | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<{
+        price: bigint;
+        minPrice: bigint;
+        maxPrice: bigint;
+        deviation: bigint;
+        numSources: bigint;
+        timestamp: bigint;
+    }, import("viem").ReadContractErrorType>>;
+};
+/**
+ * Hook to check if oracle price is fresh
+ */
+export declare function useLXOraclePriceFresh(baseToken: Address, quoteToken: Address, maxStaleness?: bigint): {
+    isFresh: boolean | undefined;
+    isLoading: boolean;
+    error: import("viem").ReadContractErrorType | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<boolean, import("viem").ReadContractErrorType>>;
+};
+/**
+ * Combined hook for market price data
+ */
+export declare function useLXMarketPrices(marketId: number): {
+    markPrice: LXMarkPrice | undefined;
+    indexPrice: bigint | undefined;
+    fundingRate: bigint | undefined;
+    nextFundingTime: bigint | undefined;
+    isLoading: boolean;
+    error: import("viem").ReadContractErrorType | null;
+    refetch: () => void;
+};
+//# sourceMappingURL=use-lxfeed.d.ts.map

package/dist/hooks/use-lxfeed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-lxfeed.d.ts","sourceRoot":"","sources":["../../src/hooks/use-lxfeed.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAGnC,OAAO,KAAK,EAAE,WAAW,EAAiB,MAAM,qBAAqB,CAAA;AAErE;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM;eAS5B,WAAW,GAAG,SAAS;;;;;;;;;EAK7C;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM;;;;;;EAiBnD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM;;;;;;EAiBpD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO;qBASzC,MAAM,GAAG,SAAS;;;;EAK9C;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO;;;;;;;;;;;;;;;;;EAcvE;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,OAAO,EAClB,UAAU,EAAE,OAAO,EACnB,YAAY,GAAE,MAAc;;;;;;;;;;;;;;;;;;;EAe7B;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,OAAO,EAClB,UAAU,EAAE,OAAO,EACnB,YAAY,GAAE,MAAc;aAUT,OAAO,GAAG,SAAS;;;;EAKvC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM;;;;;;;;EAkBjD"}

package/dist/hooks/use-lxfeed.js

@@ -0,0 +1,152 @@
+/**
+ * LXFeed Hooks (LP-9040)
+ * React hooks for price feeds, mark price, and funding rates
+ */
+import { useReadContract } from 'wagmi';
+import { LX } from '../precompile/addresses';
+import { LX_FEED_ABI, LX_ORACLE_ABI } from '../precompile/abis';
+/**
+ * Hook to get mark price for a market
+ */
+export function useLXFeedMarkPrice(marketId) {
+    const { data, isLoading, error, refetch } = useReadContract({
+        address: LX.LX_FEED,
+        abi: LX_FEED_ABI,
+        functionName: 'getMarkPrice',
+        args: [marketId],
+    });
+    return {
+        markPrice: data,
+        isLoading,
+        error,
+        refetch,
+    };
+}
+/**
+ * Hook to get index price for a market
+ */
+export function useLXFeedIndexPrice(marketId) {
+    const { data, isLoading, error, refetch } = useReadContract({
+        address: LX.LX_FEED,
+        abi: LX_FEED_ABI,
+        functionName: 'getIndexPrice',
+        args: [marketId],
+    });
+    const result = data;
+    return {
+        priceX18: result?.[0],
+        timestamp: result?.[1],
+        isLoading,
+        error,
+        refetch,
+    };
+}
+/**
+ * Hook to get funding rate for a market
+ */
+export function useLXFeedFundingRate(marketId) {
+    const { data, isLoading, error, refetch } = useReadContract({
+        address: LX.LX_FEED,
+        abi: LX_FEED_ABI,
+        functionName: 'getFundingRate',
+        args: [marketId],
+    });
+    const result = data;
+    return {
+        rateX18: result?.[0],
+        nextFundingTime: result?.[1],
+        isLoading,
+        error,
+        refetch,
+    };
+}
+/**
+ * Hook to get trigger price for stop/take orders
+ */
+export function useLXFeedTriggerPrice(marketId, isBuy) {
+    const { data, isLoading, error, refetch } = useReadContract({
+        address: LX.LX_FEED,
+        abi: LX_FEED_ABI,
+        functionName: 'getTriggerPrice',
+        args: [marketId, isBuy],
+    });
+    return {
+        triggerPriceX18: data,
+        isLoading,
+        error,
+        refetch,
+    };
+}
+/**
+ * Hook to get oracle price for token pair
+ */
+export function useLXOraclePrice(baseToken, quoteToken) {
+    const { data, isLoading, error, refetch } = useReadContract({
+        address: LX.LX_ORACLE,
+        abi: LX_ORACLE_ABI,
+        functionName: 'getPrice',
+        args: [baseToken, quoteToken],
+    });
+    return {
+        price: data,
+        isLoading,
+        error,
+        refetch,
+    };
+}
+/**
+ * Hook to get aggregated oracle price with deviation info
+ */
+export function useLXOracleAggregatedPrice(baseToken, quoteToken, maxStaleness = 3600n // 1 hour default
+) {
+    const { data, isLoading, error, refetch } = useReadContract({
+        address: LX.LX_ORACLE,
+        abi: LX_ORACLE_ABI,
+        functionName: 'getAggregatedPrice',
+        args: [baseToken, quoteToken, maxStaleness],
+    });
+    return {
+        aggregated: data,
+        isLoading,
+        error,
+        refetch,
+    };
+}
+/**
+ * Hook to check if oracle price is fresh
+ */
+export function useLXOraclePriceFresh(baseToken, quoteToken, maxStaleness = 3600n) {
+    const { data, isLoading, error, refetch } = useReadContract({
+        address: LX.LX_ORACLE,
+        abi: LX_ORACLE_ABI,
+        functionName: 'isPriceFresh',
+        args: [baseToken, quoteToken, maxStaleness],
+    });
+    return {
+        isFresh: data,
+        isLoading,
+        error,
+        refetch,
+    };
+}
+/**
+ * Combined hook for market price data
+ */
+export function useLXMarketPrices(marketId) {
+    const mark = useLXFeedMarkPrice(marketId);
+    const index = useLXFeedIndexPrice(marketId);
+    const funding = useLXFeedFundingRate(marketId);
+    return {
+        markPrice: mark.markPrice,
+        indexPrice: index.priceX18,
+        fundingRate: funding.rateX18,
+        nextFundingTime: funding.nextFundingTime,
+        isLoading: mark.isLoading || index.isLoading || funding.isLoading,
+        error: mark.error || index.error || funding.error,
+        refetch: () => {
+            mark.refetch();
+            index.refetch();
+            funding.refetch();
+        },
+    };
+}