@luxfi/dex 1.2.1 → 2.0.0

package/src/hooks/use-lxvault.ts

@@ -0,0 +1,318 @@
+/**
+ * LXVault Hooks (LP-9030)
+ * React hooks for custody, margin, and positions via LXVault precompile
+ */
+import { useCallback } from 'react'
+import { useReadContract, useWriteContract, useWaitForTransactionReceipt, useAccount } from 'wagmi'
+import type { Address } from 'viem'
+import { LX } from '../precompile/addresses'
+import { LX_VAULT_ABI } from '../precompile/abis'
+import type { LXAccount, LXPosition, LXMarginInfo } from '../precompile/types'
+
+/**
+ * Build account tuple from address and subaccount
+ */
+function buildAccount(main: Address, subaccountId: number = 0): LXAccount {
+  return { main, subaccountId }
+}
+
+/**
+ * Hook to get token balance in vault
+ */
+export function useLXVaultBalance(token: Address, subaccountId: number = 0): any {
+  const { address } = useAccount()
+
+  const { data, isLoading, error, refetch } = useReadContract({
+    address: LX.LX_VAULT,
+    abi: LX_VAULT_ABI,
+    functionName: 'getBalance',
+    args: address ? [buildAccount(address, subaccountId), token] : undefined,
+    query: { enabled: !!address },
+  })
+
+  return {
+    balance: data as bigint | undefined,
+    isLoading,
+    error,
+    refetch,
+  }
+}
+
+/**
+ * Hook to get position for a market
+ */
+export function useLXVaultPosition(marketId: number, subaccountId: number = 0): any {
+  const { address } = useAccount()
+
+  const { data, isLoading, error, refetch } = useReadContract({
+    address: LX.LX_VAULT,
+    abi: LX_VAULT_ABI,
+    functionName: 'getPosition',
+    args: address ? [buildAccount(address, subaccountId), marketId] : undefined,
+    query: { enabled: !!address },
+  })
+
+  return {
+    position: data as LXPosition | undefined,
+    isLoading,
+    error,
+    refetch,
+  }
+}
+
+/**
+ * Hook to get margin info (free margin, used margin, etc.)
+ */
+export function useLXVaultMargin(subaccountId: number = 0): any {
+  const { address } = useAccount()
+
+  const { data, isLoading, error, refetch } = useReadContract({
+    address: LX.LX_VAULT,
+    abi: LX_VAULT_ABI,
+    functionName: 'getMargin',
+    args: address ? [buildAccount(address, subaccountId)] : undefined,
+    query: { enabled: !!address },
+  })
+
+  return {
+    margin: data as LXMarginInfo | undefined,
+    isLoading,
+    error,
+    refetch,
+  }
+}
+
+/**
+ * Hook to check if account is liquidatable
+ */
+export function useLXVaultLiquidatable(account?: Address, subaccountId: number = 0): any {
+  const { address: connectedAddress } = useAccount()
+  const targetAddress = account ?? connectedAddress
+
+  const { data, isLoading, error, refetch } = useReadContract({
+    address: LX.LX_VAULT,
+    abi: LX_VAULT_ABI,
+    functionName: 'isLiquidatable',
+    args: targetAddress ? [buildAccount(targetAddress, subaccountId)] : undefined,
+    query: { enabled: !!targetAddress },
+  })
+
+  const result = data as [boolean, bigint] | undefined
+
+  return {
+    liquidatable: result?.[0],
+    shortfall: result?.[1],
+    isLoading,
+    error,
+    refetch,
+  }
+}
+
+/**
+ * Hook to get funding rate for a market
+ */
+export function useLXVaultFundingRate(marketId: number): any {
+  const { data, isLoading, error, refetch } = useReadContract({
+    address: LX.LX_VAULT,
+    abi: LX_VAULT_ABI,
+    functionName: 'getFundingRate',
+    args: [marketId],
+  })
+
+  const result = data as [bigint, bigint] | undefined
+
+  return {
+    rateX18: result?.[0],
+    nextFundingTime: result?.[1],
+    isLoading,
+    error,
+    refetch,
+  }
+}
+
+interface UseLXVaultDepositResult {
+  deposit: (token: Address, amount: bigint, subaccountId?: number) => void
+  hash: `0x${string}` | undefined
+  isPending: boolean
+  isConfirming: boolean
+  isSuccess: boolean
+  error: Error | null
+}
+
+/**
+ * Hook for depositing tokens into vault
+ */
+export function useLXVaultDeposit(): UseLXVaultDepositResult {
+  const { writeContract, data: hash, isPending, error } = useWriteContract()
+  const { isLoading: isConfirming, isSuccess } = useWaitForTransactionReceipt({ hash })
+
+  const deposit = useCallback(
+    (token: Address, amount: bigint, subaccountId: number = 0) => {
+      writeContract({
+        address: LX.LX_VAULT,
+        abi: LX_VAULT_ABI,
+        functionName: 'deposit',
+        args: [token, amount, subaccountId],
+      })
+    },
+    [writeContract]
+  )
+
+  return {
+    deposit,
+    hash,
+    isPending,
+    isConfirming,
+    isSuccess,
+    error,
+  }
+}
+
+interface UseLXVaultWithdrawResult {
+  withdraw: (token: Address, amount: bigint, subaccountId?: number) => void
+  hash: `0x${string}` | undefined
+  isPending: boolean
+  isConfirming: boolean
+  isSuccess: boolean
+  error: Error | null
+}
+
+/**
+ * Hook for withdrawing tokens from vault
+ */
+export function useLXVaultWithdraw(): UseLXVaultWithdrawResult {
+  const { writeContract, data: hash, isPending, error } = useWriteContract()
+  const { isLoading: isConfirming, isSuccess } = useWaitForTransactionReceipt({ hash })
+
+  const withdraw = useCallback(
+    (token: Address, amount: bigint, subaccountId: number = 0) => {
+      writeContract({
+        address: LX.LX_VAULT,
+        abi: LX_VAULT_ABI,
+        functionName: 'withdraw',
+        args: [token, amount, subaccountId],
+      })
+    },
+    [writeContract]
+  )
+
+  return {
+    withdraw,
+    hash,
+    isPending,
+    isConfirming,
+    isSuccess,
+    error,
+  }
+}
+
+interface UseLXVaultTransferResult {
+  transfer: (token: Address, amount: bigint, fromSubaccount: number, toSubaccount: number) => void
+  hash: `0x${string}` | undefined
+  isPending: boolean
+  isConfirming: boolean
+  isSuccess: boolean
+  error: Error | null
+}
+
+/**
+ * Hook for transferring between subaccounts
+ */
+export function useLXVaultTransfer(): UseLXVaultTransferResult {
+  const { writeContract, data: hash, isPending, error } = useWriteContract()
+  const { isLoading: isConfirming, isSuccess } = useWaitForTransactionReceipt({ hash })
+
+  const transfer = useCallback(
+    (
+      token: Address,
+      amount: bigint,
+      fromSubaccount: number,
+      toSubaccount: number
+    ) => {
+      writeContract({
+        address: LX.LX_VAULT,
+        abi: LX_VAULT_ABI,
+        functionName: 'transfer',
+        args: [token, amount, fromSubaccount, toSubaccount],
+      })
+    },
+    [writeContract]
+  )
+
+  return {
+    transfer,
+    hash,
+    isPending,
+    isConfirming,
+    isSuccess,
+    error,
+  }
+}
+
+interface UseLXVaultLiquidateResult {
+  liquidate: (targetAccount: Address, targetSubaccount: number, marketId: number, sizeX18: bigint) => void
+  hash: `0x${string}` | undefined
+  isPending: boolean
+  isConfirming: boolean
+  isSuccess: boolean
+  error: Error | null
+}
+
+/**
+ * Hook for liquidating underwater positions
+ */
+export function useLXVaultLiquidate(): UseLXVaultLiquidateResult {
+  const { writeContract, data: hash, isPending, error } = useWriteContract()
+  const { isLoading: isConfirming, isSuccess } = useWaitForTransactionReceipt({ hash })
+
+  const liquidate = useCallback(
+    (
+      targetAccount: Address,
+      targetSubaccount: number,
+      marketId: number,
+      sizeX18: bigint
+    ) => {
+      writeContract({
+        address: LX.LX_VAULT,
+        abi: LX_VAULT_ABI,
+        functionName: 'liquidate',
+        args: [buildAccount(targetAccount, targetSubaccount), marketId, sizeX18],
+      })
+    },
+    [writeContract]
+  )
+
+  return {
+    liquidate,
+    hash,
+    isPending,
+    isConfirming,
+    isSuccess,
+    error,
+  }
+}
+
+/**
+ * Combined hook for common vault operations
+ */
+export function useLXVault(subaccountId: number = 0): any {
+  const { address } = useAccount()
+  const margin = useLXVaultMargin(subaccountId)
+  const { deposit, isPending: isDepositing } = useLXVaultDeposit()
+  const { withdraw, isPending: isWithdrawing } = useLXVaultWithdraw()
+  const { transfer, isPending: isTransferring } = useLXVaultTransfer()
+
+  return {
+    address,
+    subaccountId,
+    margin: margin.margin,
+    isLoadingMargin: margin.isLoading,
+    deposit,
+    withdraw,
+    transfer,
+    isDepositing,
+    isWithdrawing,
+    isTransferring,
+    refetchMargin: margin.refetch,
+  }
+}

package/src/hooks/use-quote.ts

@@ -0,0 +1,92 @@
+'use client'
+
+import { useState, useCallback, useEffect, useRef } from 'react'
+import type { Address } from 'viem'
+import { usePublicClient } from 'wagmi'
+import { OmnichainRouter, type Quote, type QuoteRequest } from '../router'
+
+interface UseQuoteOptions {
+  refreshInterval?: number // ms
+  enabled?: boolean
+}
+
+interface UseQuoteResult {
+  quote: Quote | null
+  isLoading: boolean
+  error: Error | null
+  refetch: () => Promise<void>
+}
+
+/**
+ * Hook to get swap quotes from the omnichain router
+ */
+export function useQuote(
+  tokenIn: Address | undefined,
+  tokenOut: Address | undefined,
+  amountIn: bigint | undefined,
+  options: UseQuoteOptions = {}
+): UseQuoteResult {
+  const { refreshInterval = 10000, enabled = true } = options
+  const publicClient = usePublicClient()
+  const routerRef = useRef<OmnichainRouter | null>(null)
+
+  const [quote, setQuote] = useState<Quote | null>(null)
+  const [isLoading, setIsLoading] = useState(false)
+  const [error, setError] = useState<Error | null>(null)
+
+  // Initialize router
+  useEffect(() => {
+    if (!routerRef.current) {
+      routerRef.current = new OmnichainRouter()
+    }
+    if (publicClient) {
+      routerRef.current.setPublicClient(publicClient)
+    }
+  }, [publicClient])
+
+  const fetchQuote = useCallback(async () => {
+    if (!tokenIn || !tokenOut || !amountIn || amountIn === 0n || !enabled) {
+      setQuote(null)
+      return
+    }
+
+    setIsLoading(true)
+    setError(null)
+
+    try {
+      const request: QuoteRequest = {
+        tokenIn,
+        tokenOut,
+        amountIn,
+      }
+
+      const newQuote = await routerRef.current!.getQuote(request)
+      setQuote(newQuote)
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error('Failed to get quote'))
+      setQuote(null)
+    } finally {
+      setIsLoading(false)
+    }
+  }, [tokenIn, tokenOut, amountIn, enabled])
+
+  // Fetch on mount and when inputs change
+  useEffect(() => {
+    fetchQuote()
+  }, [fetchQuote])
+
+  // Auto-refresh
+  useEffect(() => {
+    if (!enabled || refreshInterval <= 0) return
+
+    const interval = setInterval(fetchQuote, refreshInterval)
+    return () => clearInterval(interval)
+  }, [fetchQuote, enabled, refreshInterval])
+
+  return {
+    quote,
+    isLoading,
+    error,
+    refetch: fetchQuote,
+  }
+}

package/src/hooks/use-swap.ts

@@ -0,0 +1,103 @@
+'use client'
+
+import { useState, useCallback } from 'react'
+import type { Address } from 'viem'
+import { useWriteContract, useWaitForTransactionReceipt } from 'wagmi'
+import { DEX_PRECOMPILES } from '../precompile/addresses'
+import { SWAP_ROUTER_ABI } from '../precompile/abis'
+import { createPoolKey } from '../precompile/types'
+import type { Quote } from '../router'
+
+interface UseSwapResult {
+  swap: (quote: Quote, recipient: Address) => Promise<void>
+  isPending: boolean
+  isConfirming: boolean
+  isSuccess: boolean
+  error: Error | null
+  txHash: `0x${string}` | undefined
+  reset: () => void
+}
+
+/**
+ * Hook to execute swaps via the DEX precompiles
+ */
+export function useSwap(): UseSwapResult {
+  const [error, setError] = useState<Error | null>(null)
+
+  const {
+    data: txHash,
+    writeContractAsync,
+    isPending,
+    reset: resetWrite,
+  } = useWriteContract()
+
+  const {
+    isLoading: isConfirming,
+    isSuccess,
+  } = useWaitForTransactionReceipt({
+    hash: txHash,
+  })
+
+  const swap = useCallback(async (quote: Quote, recipient: Address) => {
+    setError(null)
+
+    if (!quote || quote.route.length === 0) {
+      setError(new Error('Invalid quote'))
+      return
+    }
+
+    const step = quote.route[0]
+
+    if (step.source === 'amm') {
+      try {
+        // Execute AMM swap via precompile
+        const poolKey = createPoolKey(quote.tokenIn, quote.tokenOut)
+        const zeroForOne = quote.tokenIn.toLowerCase() < quote.tokenOut.toLowerCase()
+
+        await writeContractAsync({
+          address: DEX_PRECOMPILES.SWAP_ROUTER,
+          abi: SWAP_ROUTER_ABI,
+          functionName: 'exactInputSingle',
+          args: [{
+            poolKey,
+            zeroForOne,
+            amountIn: quote.amountIn,
+            amountOutMinimum: quote.minimumAmountOut,
+            sqrtPriceLimitX96: 0n,
+            hookData: '0x',
+          }],
+          // Include native value if swapping from native LUX
+          value: quote.tokenIn === '0x0000000000000000000000000000000000000000'
+            ? quote.amountIn
+            : 0n,
+        })
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error('Swap failed'))
+        throw err
+      }
+    } else if (step.source === 'clob') {
+      // CLOB swaps are handled off-chain
+      // The frontend should use the CLOB client directly
+      setError(new Error('CLOB swaps should be executed via CLOB client'))
+      throw new Error('CLOB swaps not supported in this hook')
+    } else {
+      setError(new Error(`Unknown route source: ${step.source}`))
+      throw new Error(`Unknown route source: ${step.source}`)
+    }
+  }, [writeContractAsync])
+
+  const reset = useCallback(() => {
+    setError(null)
+    resetWrite()
+  }, [resetWrite])
+
+  return {
+    swap,
+    isPending,
+    isConfirming,
+    isSuccess,
+    error,
+    txHash,
+    reset,
+  }
+}