@luxfi/dex 1.2.1 → 2.0.0

package/src/hooks/use-lxbook.ts

@@ -0,0 +1,343 @@
+/**
+ * LXBook Hooks (LP-9020)
+ * React hooks for CLOB trading via LXBook precompile
+ */
+import { useCallback, useMemo } from 'react'
+import { useReadContract, useWriteContract, useWaitForTransactionReceipt } from 'wagmi'
+import type { Address } from 'viem'
+import { encodeFunctionData } from 'viem'
+import { LX } from '../precompile/addresses'
+import { LX_BOOK_ABI } from '../precompile/abis'
+import {
+  type LXOrder,
+  type LXAction,
+  type LXPlaceResult,
+  type LXL1,
+  ActionType,
+  TIF,
+  OrderKind,
+} from '../precompile/types'
+
+/**
+ * Hook to get L1 (best bid/ask) for a market
+ */
+export function useLXBookL1(marketId: number): any {
+  const { data, isLoading, error, refetch } = useReadContract({
+    address: LX.LX_BOOK,
+    abi: LX_BOOK_ABI,
+    functionName: 'getL1',
+    args: [marketId],
+  })
+
+  return {
+    l1: data as LXL1 | undefined,
+    isLoading,
+    error,
+    refetch,
+  }
+}
+
+/**
+ * Hook to get market config
+ */
+export function useLXBookMarket(marketId: number) {
+  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: number) {
+  const { data, isLoading, error } = useReadContract({
+    address: LX.LX_BOOK,
+    abi: LX_BOOK_ABI,
+    functionName: 'getMarketStatus',
+    args: [marketId],
+  })
+
+  return {
+    status: data as number | undefined,
+    isLoading,
+    error,
+  }
+}
+
+/**
+ * Build action payload for execute()
+ */
+function buildAction(
+  actionType: ActionType,
+  nonce: bigint,
+  expiresAfter: bigint,
+  data: `0x${string}`
+): LXAction {
+  return {
+    actionType,
+    nonce,
+    expiresAfter,
+    data,
+  }
+}
+
+/**
+ * Encode order data for placement
+ */
+function encodeOrderData(order: LXOrder): `0x${string}` {
+  // 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)}` as `0x${string}`
+}
+
+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 function useLXBookExecute(): UseLXBookExecuteResult {
+  const { writeContract, data: hash, isPending, error } = useWriteContract()
+  const { isLoading: isConfirming, isSuccess } = useWaitForTransactionReceipt({ hash })
+
+  const execute = useCallback(
+    (action: LXAction) => {
+      writeContract({
+        address: LX.LX_BOOK,
+        abi: LX_BOOK_ABI,
+        functionName: 'execute',
+        args: [action],
+      })
+    },
+    [writeContract]
+  )
+
+  const executeBatch = useCallback(
+    (actions: LXAction[]) => {
+      writeContract({
+        address: LX.LX_BOOK,
+        abi: LX_BOOK_ABI,
+        functionName: 'executeBatch',
+        args: [actions],
+      })
+    },
+    [writeContract]
+  )
+
+  return {
+    execute,
+    executeBatch,
+    hash,
+    isPending,
+    isConfirming,
+    isSuccess,
+    error,
+  }
+}
+
+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 function useLXBookPlaceOrder(): UseLXBookPlaceOrderResult {
+  const { execute, hash, isPending, isConfirming, isSuccess, error } = useLXBookExecute()
+
+  const placeOrder = useCallback(
+    async (params: {
+      marketId: number
+      isBuy: boolean
+      size: bigint
+      price: bigint
+      tif?: TIF
+      reduceOnly?: boolean
+      cloid?: `0x${string}`
+    }) => {
+      const order: LXOrder = {
+        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: {
+      marketId: number
+      isBuy: boolean
+      size: bigint
+      reduceOnly?: boolean
+    }) => {
+      const order: LXOrder = {
+        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,
+  }
+}
+
+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 function useLXBookCancelOrder(): UseLXBookCancelOrderResult {
+  const { execute, hash, isPending, isConfirming, isSuccess, error } = useLXBookExecute()
+
+  const cancelByOid = useCallback(
+    async (oid: bigint) => {
+      // Encode oid as bytes
+      const data = `0x${oid.toString(16).padStart(64, '0')}` as `0x${string}`
+      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: `0x${string}`) => {
+      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/src/hooks/use-lxfeed.ts

@@ -0,0 +1,179 @@
+/**
+ * LXFeed Hooks (LP-9040)
+ * React hooks for price feeds, mark price, and funding rates
+ */
+import { useReadContract } from 'wagmi'
+import type { Address } from 'viem'
+import { LX } from '../precompile/addresses'
+import { LX_FEED_ABI, LX_ORACLE_ABI } from '../precompile/abis'
+import type { LXMarkPrice, LXFundingRate } from '../precompile/types'
+
+/**
+ * Hook to get mark price for a market
+ */
+export function useLXFeedMarkPrice(marketId: number): any {
+  const { data, isLoading, error, refetch } = useReadContract({
+    address: LX.LX_FEED,
+    abi: LX_FEED_ABI,
+    functionName: 'getMarkPrice',
+    args: [marketId],
+  })
+
+  return {
+    markPrice: data as LXMarkPrice | undefined,
+    isLoading,
+    error,
+    refetch,
+  }
+}
+
+/**
+ * Hook to get index price for a market
+ */
+export function useLXFeedIndexPrice(marketId: number): any {
+  const { data, isLoading, error, refetch } = useReadContract({
+    address: LX.LX_FEED,
+    abi: LX_FEED_ABI,
+    functionName: 'getIndexPrice',
+    args: [marketId],
+  })
+
+  const result = data as [bigint, bigint] | undefined
+
+  return {
+    priceX18: result?.[0],
+    timestamp: result?.[1],
+    isLoading,
+    error,
+    refetch,
+  }
+}
+
+/**
+ * Hook to get funding rate for a market
+ */
+export function useLXFeedFundingRate(marketId: number): any {
+  const { data, isLoading, error, refetch } = useReadContract({
+    address: LX.LX_FEED,
+    abi: LX_FEED_ABI,
+    functionName: 'getFundingRate',
+    args: [marketId],
+  })
+
+  const result = data as [bigint, bigint] | undefined
+
+  return {
+    rateX18: result?.[0],
+    nextFundingTime: result?.[1],
+    isLoading,
+    error,
+    refetch,
+  }
+}
+
+/**
+ * Hook to get trigger price for stop/take orders
+ */
+export function useLXFeedTriggerPrice(marketId: number, isBuy: boolean): any {
+  const { data, isLoading, error, refetch } = useReadContract({
+    address: LX.LX_FEED,
+    abi: LX_FEED_ABI,
+    functionName: 'getTriggerPrice',
+    args: [marketId, isBuy],
+  })
+
+  return {
+    triggerPriceX18: data as bigint | undefined,
+    isLoading,
+    error,
+    refetch,
+  }
+}
+
+/**
+ * Hook to get oracle price for token pair
+ */
+export function useLXOraclePrice(baseToken: Address, quoteToken: Address): any {
+  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: Address,
+  quoteToken: Address,
+  maxStaleness: bigint = 3600n // 1 hour default
+): any {
+  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: Address,
+  quoteToken: Address,
+  maxStaleness: bigint = 3600n
+): any {
+  const { data, isLoading, error, refetch } = useReadContract({
+    address: LX.LX_ORACLE,
+    abi: LX_ORACLE_ABI,
+    functionName: 'isPriceFresh',
+    args: [baseToken, quoteToken, maxStaleness],
+  })
+
+  return {
+    isFresh: data as boolean | undefined,
+    isLoading,
+    error,
+    refetch,
+  }
+}
+
+/**
+ * Combined hook for market price data
+ */
+export function useLXMarketPrices(marketId: number) {
+  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()
+    },
+  }
+}