@luxfi/exchange 0.1.0

package/src/hooks/use-swap-quote.ts

@@ -0,0 +1,81 @@
+'use client'
+
+import { useQuery } from '@tanstack/react-query'
+import { usePublicClient } from 'wagmi'
+import { getContracts } from '../contracts'
+import { QUOTER_V2_ABI } from '../contracts/abis'
+import type { Token } from '../tokens'
+
+export interface SwapQuote {
+  amountIn: bigint
+  amountOut: bigint
+  priceImpact: number
+  route: Token[]
+  gasEstimate: bigint
+}
+
+export interface UseSwapQuoteParams {
+  tokenIn: Token | null
+  tokenOut: Token | null
+  amountIn: bigint
+  chainId: number
+}
+
+/**
+ * Hook to get swap quote from V3 Quoter
+ */
+export function useSwapQuote({
+  tokenIn,
+  tokenOut,
+  amountIn,
+  chainId,
+}: UseSwapQuoteParams) {
+  const publicClient = usePublicClient({ chainId })
+  const contracts = getContracts(chainId)
+
+  return useQuery({
+    queryKey: ['swapQuote', tokenIn?.address, tokenOut?.address, amountIn.toString(), chainId],
+    queryFn: async (): Promise<SwapQuote | null> => {
+      if (!tokenIn || !tokenOut || amountIn === 0n || !publicClient) {
+        return null
+      }
+
+      try {
+        // Call QuoterV2 for quote
+        const result = await publicClient.simulateContract({
+          address: contracts.V3_QUOTER_V2,
+          abi: QUOTER_V2_ABI,
+          functionName: 'quoteExactInputSingle',
+          args: [
+            {
+              tokenIn: tokenIn.address,
+              tokenOut: tokenOut.address,
+              amountIn,
+              fee: 3000, // 0.30% fee tier
+              sqrtPriceLimitX96: 0n,
+            },
+          ],
+        })
+
+        const [amountOut, , , gasEstimate] = result.result as [bigint, bigint, number, bigint]
+
+        // Calculate price impact (simplified)
+        const priceImpact = 0.003 // 0.3% placeholder
+
+        return {
+          amountIn,
+          amountOut,
+          priceImpact,
+          route: [tokenIn, tokenOut],
+          gasEstimate,
+        }
+      } catch (error) {
+        console.error('Failed to get swap quote:', error)
+        return null
+      }
+    },
+    enabled: !!tokenIn && !!tokenOut && amountIn > 0n && !!publicClient,
+    staleTime: 10_000, // 10 seconds
+    refetchInterval: 15_000, // Refetch every 15 seconds
+  })
+}

package/src/hooks/use-swap.ts

@@ -0,0 +1,64 @@
+'use client'
+
+import { useMutation } from '@tanstack/react-query'
+import { useWriteContract, useWaitForTransactionReceipt } from 'wagmi'
+import { parseUnits } from 'viem'
+import { getContracts } from '../contracts'
+import { SWAP_ROUTER_ABI } from '../contracts/abis'
+import type { Token } from '../tokens'
+import { isNativeToken } from '../tokens'
+
+export interface SwapRequest {
+  tokenIn: Token
+  tokenOut: Token
+  amountIn: bigint
+  amountOutMinimum: bigint
+  recipient: `0x${string}`
+  deadline: bigint
+  chainId: number
+}
+
+/**
+ * Hook to execute a swap transaction
+ */
+export function useSwap() {
+  const { writeContractAsync, data: hash, isPending } = useWriteContract()
+  const { isLoading: isConfirming, isSuccess } = useWaitForTransactionReceipt({ hash })
+
+  const swap = useMutation({
+    mutationFn: async (params: SwapRequest) => {
+      const contracts = getContracts(params.chainId)
+      const isNativeIn = isNativeToken(params.tokenIn)
+
+      const txHash = await writeContractAsync({
+        address: contracts.V3_SWAP_ROUTER_02,
+        abi: SWAP_ROUTER_ABI,
+        functionName: 'exactInputSingle',
+        args: [
+          {
+            tokenIn: isNativeIn ? contracts.WLUX : params.tokenIn.address,
+            tokenOut: params.tokenOut.address,
+            fee: 3000, // 0.30% fee tier
+            recipient: params.recipient,
+            deadline: params.deadline,
+            amountIn: params.amountIn,
+            amountOutMinimum: params.amountOutMinimum,
+            sqrtPriceLimitX96: 0n,
+          },
+        ],
+        value: isNativeIn ? params.amountIn : 0n,
+      })
+
+      return txHash
+    },
+  })
+
+  return {
+    swap: swap.mutateAsync,
+    hash,
+    isPending: isPending || swap.isPending,
+    isConfirming,
+    isSuccess,
+    error: swap.error,
+  }
+}

package/src/hooks/use-token-allowance.ts

@@ -0,0 +1,74 @@
+'use client'
+
+import { useReadContract, useWriteContract, useWaitForTransactionReceipt } from 'wagmi'
+import { maxUint256 } from 'viem'
+import { ERC20_ABI } from '../contracts/abis'
+import type { Token } from '../tokens'
+import { isNativeToken } from '../tokens'
+import type { Address } from 'viem'
+
+/**
+ * Hook to check and manage token allowance
+ */
+export function useTokenAllowance(
+  token: Token | null,
+  owner: Address | undefined,
+  spender: Address | undefined,
+  chainId: number
+) {
+  const allowance = useReadContract({
+    address: token?.address,
+    abi: ERC20_ABI,
+    functionName: 'allowance',
+    args: owner && spender ? [owner, spender] : undefined,
+    chainId,
+    query: {
+      enabled: !!token && !isNativeToken(token) && !!owner && !!spender,
+    },
+  })
+
+  const { writeContractAsync, data: hash, isPending } = useWriteContract()
+  const { isLoading: isConfirming, isSuccess } = useWaitForTransactionReceipt({ hash })
+
+  const approve = async (amount: bigint = maxUint256) => {
+    if (!token || !spender || isNativeToken(token)) return
+
+    return writeContractAsync({
+      address: token.address,
+      abi: ERC20_ABI,
+      functionName: 'approve',
+      args: [spender, amount],
+    })
+  }
+
+  // Native tokens don't need approval
+  if (token && isNativeToken(token)) {
+    return {
+      allowance: maxUint256,
+      isApproved: true,
+      approve,
+      isPending: false,
+      isConfirming: false,
+      isSuccess: true,
+    }
+  }
+
+  const currentAllowance = (allowance.data as bigint) ?? 0n
+
+  return {
+    allowance: currentAllowance,
+    isApproved: currentAllowance > 0n,
+    approve,
+    isPending,
+    isConfirming,
+    isSuccess,
+    refetch: allowance.refetch,
+  }
+}
+
+/**
+ * Check if approval is needed for a specific amount
+ */
+export function needsApproval(allowance: bigint, amount: bigint): boolean {
+  return allowance < amount
+}

package/src/hooks/use-token-balance.ts

@@ -0,0 +1,71 @@
+'use client'
+
+import { useBalance, useReadContract } from 'wagmi'
+import { ERC20_ABI } from '../contracts/abis'
+import type { Token } from '../tokens'
+import { isNativeToken } from '../tokens'
+import type { Address } from 'viem'
+
+/**
+ * Hook to get token balance for an address
+ */
+export function useTokenBalance(
+  token: Token | null,
+  address: Address | undefined,
+  chainId: number
+) {
+  // For native token
+  const nativeBalance = useBalance({
+    address,
+    chainId,
+    query: {
+      enabled: !!token && isNativeToken(token) && !!address,
+    },
+  })
+
+  // For ERC20 token
+  const erc20Balance = useReadContract({
+    address: token?.address,
+    abi: ERC20_ABI,
+    functionName: 'balanceOf',
+    args: address ? [address] : undefined,
+    chainId,
+    query: {
+      enabled: !!token && !isNativeToken(token) && !!address,
+    },
+  })
+
+  if (!token || !address) {
+    return {
+      balance: 0n,
+      formatted: '0',
+      isLoading: false,
+      error: null,
+    }
+  }
+
+  if (isNativeToken(token)) {
+    const value = nativeBalance.data?.value ?? 0n
+    return {
+      balance: value,
+      formatted: formatBalance(value, token.decimals),
+      isLoading: nativeBalance.isLoading,
+      error: nativeBalance.error,
+    }
+  }
+
+  return {
+    balance: (erc20Balance.data as bigint) ?? 0n,
+    formatted: formatBalance((erc20Balance.data as bigint) ?? 0n, token.decimals),
+    isLoading: erc20Balance.isLoading,
+    error: erc20Balance.error,
+  }
+}
+
+function formatBalance(value: bigint, decimals: number): string {
+  const divisor = 10n ** BigInt(decimals)
+  const whole = value / divisor
+  const fraction = value % divisor
+  const fractionStr = fraction.toString().padStart(decimals, '0').slice(0, 6)
+  return `${whole}.${fractionStr}`.replace(/\.?0+$/, '')
+}

package/src/index.ts

@@ -0,0 +1,31 @@
+/**
+ * @luxfi/exchange - Core DEX logic for Lux Exchange
+ *
+ * Provides:
+ * - Chain and token definitions
+ * - AMM V2/V3 contract interfaces
+ * - DEX precompile integration
+ * - Swap/liquidity hooks
+ * - Zustand stores for state management
+ */
+
+// Chains
+export * from './chains'
+
+// Tokens
+export * from './tokens'
+
+// Contracts & ABIs
+export * from './contracts'
+
+// DEX types
+export * from './dex'
+
+// Hooks
+export * from './hooks'
+
+// Stores
+export * from './stores'
+
+// Note: Bridge module is experimental and will be added in a future release
+// See bridge-wip/ for the work-in-progress implementation

package/src/stores/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Zustand stores for state management
+ */
+
+export * from './swap-store'
+export * from './token-store'
+export * from './settings-store'

package/src/stores/settings-store.ts

@@ -0,0 +1,54 @@
+import { create } from 'zustand'
+import { persist } from 'zustand/middleware'
+
+export type RouterPreference = 'auto' | 'v2' | 'v3' | 'precompile'
+
+export interface SettingsStore {
+  // Router preference
+  routerPreference: RouterPreference
+
+  // Expert mode (skip confirmation modals)
+  expertMode: boolean
+
+  // Auto slippage
+  autoSlippage: boolean
+
+  // Hide small balances
+  hideSmallBalances: boolean
+
+  // Small balance threshold (in USD)
+  smallBalanceThreshold: number
+
+  // Actions
+  setRouterPreference: (preference: RouterPreference) => void
+  toggleExpertMode: () => void
+  toggleAutoSlippage: () => void
+  toggleHideSmallBalances: () => void
+  setSmallBalanceThreshold: (threshold: number) => void
+}
+
+export const useSettingsStore = create<SettingsStore>()(
+  persist(
+    (set) => ({
+      routerPreference: 'auto',
+      expertMode: false,
+      autoSlippage: true,
+      hideSmallBalances: false,
+      smallBalanceThreshold: 1,
+
+      setRouterPreference: (preference) => set({ routerPreference: preference }),
+
+      toggleExpertMode: () => set((state) => ({ expertMode: !state.expertMode })),
+
+      toggleAutoSlippage: () => set((state) => ({ autoSlippage: !state.autoSlippage })),
+
+      toggleHideSmallBalances: () =>
+        set((state) => ({ hideSmallBalances: !state.hideSmallBalances })),
+
+      setSmallBalanceThreshold: (threshold) => set({ smallBalanceThreshold: threshold }),
+    }),
+    {
+      name: 'settings-storage',
+    }
+  )
+)

package/src/stores/swap-store.ts

@@ -0,0 +1,112 @@
+import { create } from 'zustand'
+import { persist } from 'zustand/middleware'
+import type { Token } from '../tokens'
+
+export type SwapField = 'input' | 'output'
+
+export interface SwapState {
+  // Tokens
+  tokenIn: Token | null
+  tokenOut: Token | null
+
+  // Amounts (as strings for input fields)
+  amountIn: string
+  amountOut: string
+
+  // Which field is being typed in
+  independentField: SwapField
+
+  // Slippage tolerance (in basis points, e.g., 50 = 0.5%)
+  slippageTolerance: number
+
+  // Transaction deadline (in minutes)
+  deadline: number
+
+  // Actions
+  setTokenIn: (token: Token | null) => void
+  setTokenOut: (token: Token | null) => void
+  setAmountIn: (amount: string) => void
+  setAmountOut: (amount: string) => void
+  setIndependentField: (field: SwapField) => void
+  setSlippageTolerance: (tolerance: number) => void
+  setDeadline: (deadline: number) => void
+  switchTokens: () => void
+  reset: () => void
+}
+
+const initialState = {
+  tokenIn: null,
+  tokenOut: null,
+  amountIn: '',
+  amountOut: '',
+  independentField: 'input' as SwapField,
+  slippageTolerance: 50, // 0.5%
+  deadline: 30, // 30 minutes
+}
+
+export const useSwapStore = create<SwapState>()(
+  persist(
+    (set) => ({
+      ...initialState,
+
+      setTokenIn: (token) =>
+        set((state) => {
+          // If selecting same token as output, switch them
+          if (token && state.tokenOut && token.address === state.tokenOut.address) {
+            return {
+              tokenIn: token,
+              tokenOut: state.tokenIn,
+            }
+          }
+          return { tokenIn: token }
+        }),
+
+      setTokenOut: (token) =>
+        set((state) => {
+          // If selecting same token as input, switch them
+          if (token && state.tokenIn && token.address === state.tokenIn.address) {
+            return {
+              tokenOut: token,
+              tokenIn: state.tokenOut,
+            }
+          }
+          return { tokenOut: token }
+        }),
+
+      setAmountIn: (amount) =>
+        set({
+          amountIn: amount,
+          independentField: 'input',
+        }),
+
+      setAmountOut: (amount) =>
+        set({
+          amountOut: amount,
+          independentField: 'output',
+        }),
+
+      setIndependentField: (field) => set({ independentField: field }),
+
+      setSlippageTolerance: (tolerance) => set({ slippageTolerance: tolerance }),
+
+      setDeadline: (deadline) => set({ deadline: deadline }),
+
+      switchTokens: () =>
+        set((state) => ({
+          tokenIn: state.tokenOut,
+          tokenOut: state.tokenIn,
+          amountIn: state.amountOut,
+          amountOut: state.amountIn,
+        })),
+
+      reset: () => set(initialState),
+    }),
+    {
+      name: 'swap-storage',
+      partialize: (state) => ({
+        slippageTolerance: state.slippageTolerance,
+        deadline: state.deadline,
+      }),
+    }
+  )
+)

package/src/stores/token-store.ts

@@ -0,0 +1,62 @@
+import { create } from 'zustand'
+import { persist } from 'zustand/middleware'
+import type { Token } from '../tokens'
+
+export interface TokenStore {
+  // Custom tokens added by user
+  customTokens: Token[]
+
+  // Favorite tokens
+  favoriteTokens: string[] // addresses
+
+  // Actions
+  addCustomToken: (token: Token) => void
+  removeCustomToken: (address: string) => void
+  toggleFavorite: (address: string) => void
+  isFavorite: (address: string) => boolean
+}
+
+export const useTokenStore = create<TokenStore>()(
+  persist(
+    (set, get) => ({
+      customTokens: [],
+      favoriteTokens: [],
+
+      addCustomToken: (token) =>
+        set((state) => {
+          // Check if token already exists
+          if (state.customTokens.some((t) => t.address.toLowerCase() === token.address.toLowerCase())) {
+            return state
+          }
+          return { customTokens: [...state.customTokens, token] }
+        }),
+
+      removeCustomToken: (address) =>
+        set((state) => ({
+          customTokens: state.customTokens.filter(
+            (t) => t.address.toLowerCase() !== address.toLowerCase()
+          ),
+        })),
+
+      toggleFavorite: (address) =>
+        set((state) => {
+          const normalized = address.toLowerCase()
+          if (state.favoriteTokens.includes(normalized)) {
+            return {
+              favoriteTokens: state.favoriteTokens.filter((a) => a !== normalized),
+            }
+          }
+          return {
+            favoriteTokens: [...state.favoriteTokens, normalized],
+          }
+        }),
+
+      isFavorite: (address) => {
+        return get().favoriteTokens.includes(address.toLowerCase())
+      },
+    }),
+    {
+      name: 'token-storage',
+    }
+  )
+)