@luxfi/dex 1.2.1 → 1.3.0

package/src/precompile/addresses.ts

@@ -0,0 +1,72 @@
+/**
+ * DEX Precompile Addresses
+ * Native Go implementation at EVM level
+ * 
+ * Lux Precompile Address Standard:
+ * - Prefix format: 0xNNNN000000000000000000000000000000000000
+ * - Range 0x0400-0x04FF is reserved for DEX precompiles
+ * 
+ * @see ~/work/lux/precompile/dex/module.go for implementation
+ */
+import type { Address } from 'viem'
+
+/**
+ * DEX Precompile contract addresses
+ * These are native precompiles, not deployed contracts
+ */
+export const DEX_PRECOMPILES = {
+  /**
+   * PoolManager (0x0400)
+   * Singleton managing all liquidity pools
+   * - Initialize pools
+   * - Execute swaps
+   * - Modify liquidity
+   * - Flash accounting settlement
+   */
+  POOL_MANAGER: '0x0400000000000000000000000000000000000000' as Address,
+
+  /**
+   * SwapRouter (0x0401)
+   * Optimized swap routing
+   * - exactInputSingle / exactOutputSingle
+   * - Multi-hop swaps
+   * - Native LUX support
+   */
+  SWAP_ROUTER: '0x0401000000000000000000000000000000000000' as Address,
+
+  /**
+   * HooksRegistry (0x0402)
+   * Hook contract registry
+   * - Register hook contracts
+   * - Query hook permissions
+   */
+  HOOKS_REGISTRY: '0x0402000000000000000000000000000000000000' as Address,
+
+  /**
+   * FlashLoan (0x0403)
+   * Flash loan facility
+   * - Borrow any token
+   * - Repay in same transaction
+   */
+  FLASH_LOAN: '0x0403000000000000000000000000000000000000' as Address,
+
+  /**
+   * Lending (0x0410)
+   * Lending protocol
+   */
+  LENDING: '0x0410000000000000000000000000000000000000' as Address,
+
+  /**
+   * Liquid (0x0430)
+   * Liquid staking vaults
+   */
+  LIQUID: '0x0430000000000000000000000000000000000000' as Address,
+
+  /**
+   * Teleport (0x0440)
+   * Cross-chain bridge
+   */
+  TELEPORT: '0x0440000000000000000000000000000000000000' as Address,
+} as const
+
+export type DexPrecompile = keyof typeof DEX_PRECOMPILES

package/src/precompile/index.ts

@@ -0,0 +1,7 @@
+/**
+ * DEX Precompile Exports
+ * Native Uniswap v4-style AMM at 0x0400-0x0403
+ */
+export * from './types'
+export * from './abis'
+export * from './addresses'

package/src/precompile/types.ts

@@ -0,0 +1,96 @@
+/**
+ * DEX Precompile Types
+ * Native Uniswap v4-style AMM implementation
+ */
+import type { Address } from 'viem'
+
+/**
+ * Currency type - address(0) = native LUX
+ */
+export interface Currency {
+  address: Address
+}
+
+/**
+ * Pool key uniquely identifies a pool
+ */
+export interface PoolKey {
+  currency0: Address // Lower address token (sorted)
+  currency1: Address // Higher address token (sorted)
+  fee: number // Fee in basis points (3000 = 0.30%)
+  tickSpacing: number // Tick spacing for concentrated liquidity
+  hooks: Address // Hook contract (address(0) = no hooks)
+}
+
+/**
+ * Balance delta from swap/liquidity operations
+ * Positive = user owes pool, Negative = pool owes user
+ */
+export interface BalanceDelta {
+  amount0: bigint
+  amount1: bigint
+}
+
+/**
+ * Swap parameters
+ */
+export interface SwapParams {
+  zeroForOne: boolean // true = swap token0 for token1
+  amountSpecified: bigint // Positive = exact input, Negative = exact output
+  sqrtPriceLimitX96: bigint // Price limit (0 = no limit)
+}
+
+/**
+ * Modify liquidity parameters
+ */
+export interface ModifyLiquidityParams {
+  tickLower: number
+  tickUpper: number
+  liquidityDelta: bigint
+  salt: `0x${string}`
+}
+
+/**
+ * Pool state
+ */
+export interface PoolState {
+  sqrtPriceX96: bigint
+  tick: number
+  protocolFee: number
+  lpFee: number
+}
+
+/**
+ * Position info
+ */
+export interface Position {
+  liquidity: bigint
+  feeGrowthInside0LastX128: bigint
+  feeGrowthInside1LastX128: bigint
+}
+
+/**
+ * Native LUX currency constant
+ */
+export const NATIVE_LUX: Address = '0x0000000000000000000000000000000000000000'
+
+/**
+ * Sort currencies for pool key creation
+ */
+export function sortCurrencies(a: Address, b: Address): [Address, Address] {
+  return a.toLowerCase() < b.toLowerCase() ? [a, b] : [b, a]
+}
+
+/**
+ * Create a pool key from two currencies
+ */
+export function createPoolKey(
+  tokenA: Address,
+  tokenB: Address,
+  fee: number = 3000,
+  tickSpacing: number = 60,
+  hooks: Address = '0x0000000000000000000000000000000000000000'
+): PoolKey {
+  const [currency0, currency1] = sortCurrencies(tokenA, tokenB)
+  return { currency0, currency1, fee, tickSpacing, hooks }
+}

package/src/router/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Router Exports
+ * Omnichain routing between CLOB and AMM
+ */
+export * from './types'
+export * from './router'

package/src/router/router.ts

@@ -0,0 +1,338 @@
+/**
+ * Omnichain Router
+ * Routes orders between CLOB and AMM for best execution
+ */
+import type { Address, PublicClient } from 'viem'
+import { DEX_PRECOMPILES } from '../precompile/addresses'
+import { POOL_MANAGER_ABI, SWAP_ROUTER_ABI } from '../precompile/abis'
+import { createPoolKey, type PoolKey } from '../precompile/types'
+import type { ICLOBClient } from '../client/types'
+import type {
+  RouterConfig,
+  QuoteRequest,
+  Quote,
+  RouteStep,
+  SwapRequest,
+  SwapResult,
+} from './types'
+
+const DEFAULT_CONFIG: RouterConfig = {
+  clobEnabled: true,
+  ammEnabled: true,
+  maxHops: 3,
+  preferCLOB: false,
+  hybridEnabled: true,
+}
+
+/**
+ * Omnichain Router
+ * Best execution routing between CLOB and AMM
+ */
+export class OmnichainRouter {
+  private config: RouterConfig
+  private publicClient: PublicClient | null = null
+  private clobClient: ICLOBClient | null = null
+
+  constructor(config: Partial<RouterConfig> = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config }
+  }
+
+  /**
+   * Set the public client for AMM interactions
+   */
+  setPublicClient(client: PublicClient) {
+    this.publicClient = client
+  }
+
+  /**
+   * Set the CLOB client
+   */
+  setCLOBClient(client: ICLOBClient) {
+    this.clobClient = client
+  }
+
+  /**
+   * Get a quote for a swap
+   */
+  async getQuote(request: QuoteRequest): Promise<Quote> {
+    const {
+      tokenIn,
+      tokenOut,
+      amountIn,
+      slippageTolerance = 50, // 0.5%
+      preferredSource,
+    } = request
+
+    const quotes: Quote[] = []
+
+    // Get AMM quote if enabled
+    if (this.config.ammEnabled && (!preferredSource || preferredSource !== 'clob')) {
+      try {
+        const ammQuote = await this.getAMMQuote(tokenIn, tokenOut, amountIn)
+        if (ammQuote) quotes.push(ammQuote)
+      } catch (error) {
+        console.warn('AMM quote failed:', error)
+      }
+    }
+
+    // Get CLOB quote if enabled
+    if (this.config.clobEnabled && this.clobClient && (!preferredSource || preferredSource !== 'amm')) {
+      try {
+        const clobQuote = await this.getCLOBQuote(tokenIn, tokenOut, amountIn)
+        if (clobQuote) quotes.push(clobQuote)
+      } catch (error) {
+        console.warn('CLOB quote failed:', error)
+      }
+    }
+
+    if (quotes.length === 0) {
+      throw new Error('No quotes available')
+    }
+
+    // Select best quote (highest output)
+    const bestQuote = quotes.reduce((best, quote) =>
+      quote.amountOut > best.amountOut ? quote : best
+    )
+
+    // Apply slippage tolerance
+    const minimumAmountOut = bestQuote.amountOut - (bestQuote.amountOut * BigInt(slippageTolerance)) / 10000n
+
+    return {
+      ...bestQuote,
+      minimumAmountOut,
+      validUntil: Date.now() + 30000, // 30 seconds
+    }
+  }
+
+  /**
+   * Get AMM quote using precompiles
+   */
+  private async getAMMQuote(
+    tokenIn: Address,
+    tokenOut: Address,
+    amountIn: bigint
+  ): Promise<Quote | null> {
+    if (!this.publicClient) return null
+
+    try {
+      // Create pool key
+      const poolKey = createPoolKey(tokenIn, tokenOut)
+      const zeroForOne = tokenIn.toLowerCase() < tokenOut.toLowerCase()
+
+      // Get pool state
+      const slot0 = await this.publicClient.readContract({
+        address: DEX_PRECOMPILES.POOL_MANAGER,
+        abi: POOL_MANAGER_ABI,
+        functionName: 'getSlot0',
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        args: [poolKey] as any,
+      }) as [bigint, number, number, number]
+
+      if (slot0[0] === 0n) {
+        return null // Pool doesn't exist
+      }
+
+      // Calculate expected output (simplified - real implementation would use tick math)
+      // For now, use a simple estimate based on sqrt price
+      const sqrtPriceX96 = slot0[0]
+      const price = (sqrtPriceX96 * sqrtPriceX96) / (2n ** 192n)
+      const amountOut = zeroForOne
+        ? (amountIn * price) / (10n ** 18n)
+        : (amountIn * (10n ** 18n)) / price
+
+      // Estimate price impact (simplified)
+      const priceImpact = Number((amountIn * 10n) / (amountIn + amountOut))
+
+      const step: RouteStep = {
+        source: 'amm',
+        tokenIn,
+        tokenOut,
+        amountIn,
+        amountOut,
+        pool: DEX_PRECOMPILES.POOL_MANAGER,
+        fee: (amountIn * BigInt(poolKey.fee)) / 1_000_000n,
+        priceImpact,
+      }
+
+      return {
+        tokenIn,
+        tokenOut,
+        amountIn,
+        amountOut,
+        minimumAmountOut: amountOut,
+        route: [step],
+        priceImpact,
+        estimatedGas: 150_000n,
+        validUntil: Date.now() + 30000,
+      }
+    } catch (error) {
+      console.error('AMM quote error:', error)
+      return null
+    }
+  }
+
+  /**
+   * Get CLOB quote
+   */
+  private async getCLOBQuote(
+    tokenIn: Address,
+    tokenOut: Address,
+    amountIn: bigint
+  ): Promise<Quote | null> {
+    if (!this.clobClient || !this.clobClient.isConnected()) return null
+
+    try {
+      // Convert addresses to symbol (e.g., "LUX-USDT")
+      const symbol = this.getSymbol(tokenIn, tokenOut)
+      if (!symbol) return null
+
+      const orderBook = await this.clobClient.getOrderBook(symbol, 50)
+
+      // Calculate output by walking the order book
+      let remainingIn = amountIn
+      let totalOut = 0n
+      const side = tokenIn.toLowerCase() < tokenOut.toLowerCase() ? 'asks' : 'bids'
+      const levels = side === 'asks' ? orderBook.asks : orderBook.bids
+
+      for (const level of levels) {
+        if (remainingIn <= 0n) break
+
+        const levelSize = BigInt(Math.floor(level.size * 1e18))
+        const levelPrice = BigInt(Math.floor(level.price * 1e18))
+
+        const fillSize = remainingIn < levelSize ? remainingIn : levelSize
+        const fillOut = side === 'asks'
+          ? (fillSize * (10n ** 18n)) / levelPrice
+          : (fillSize * levelPrice) / (10n ** 18n)
+
+        totalOut += fillOut
+        remainingIn -= fillSize
+      }
+
+      if (totalOut === 0n) return null
+
+      // Calculate price impact
+      const avgPrice = (amountIn * (10n ** 18n)) / totalOut
+      const bestPrice = BigInt(Math.floor(levels[0]?.price * 1e18 || 0))
+      const priceImpact = bestPrice > 0n
+        ? Number(((avgPrice - bestPrice) * 10000n) / bestPrice)
+        : 0
+
+      const step: RouteStep = {
+        source: 'clob',
+        tokenIn,
+        tokenOut,
+        amountIn,
+        amountOut: totalOut,
+        symbol,
+        fee: (amountIn * 30n) / 10000n, // 0.3% maker fee estimate
+        priceImpact,
+      }
+
+      return {
+        tokenIn,
+        tokenOut,
+        amountIn,
+        amountOut: totalOut,
+        minimumAmountOut: totalOut,
+        route: [step],
+        priceImpact,
+        estimatedGas: 50_000n, // CLOB is off-chain
+        validUntil: Date.now() + 10000, // 10 seconds (faster expiry for CLOB)
+      }
+    } catch (error) {
+      console.error('CLOB quote error:', error)
+      return null
+    }
+  }
+
+  /**
+   * Convert token addresses to trading symbol
+   */
+  private getSymbol(tokenIn: Address, tokenOut: Address): string | null {
+    // TODO: Implement proper token-to-symbol mapping
+    // This should look up the token registry
+    const tokenMap: Record<string, string> = {
+      '0x0000000000000000000000000000000000000000': 'LUX',
+      // Add more tokens as needed
+    }
+
+    const symbolIn = tokenMap[tokenIn.toLowerCase()]
+    const symbolOut = tokenMap[tokenOut.toLowerCase()]
+
+    if (!symbolIn || !symbolOut) return null
+
+    return `${symbolIn}-${symbolOut}`
+  }
+
+  /**
+   * Execute a swap
+   */
+  async executeSwap(request: SwapRequest): Promise<SwapResult> {
+    const { quote, recipient, deadline = Math.floor(Date.now() / 1000) + 1200 } = request
+
+    if (Date.now() > quote.validUntil) {
+      throw new Error('Quote expired')
+    }
+
+    // Determine execution path
+    const source = quote.route[0]?.source
+
+    if (source === 'amm') {
+      return this.executeAMMSwap(quote, recipient, deadline)
+    } else if (source === 'clob') {
+      return this.executeCLOBSwap(quote, recipient)
+    } else {
+      throw new Error(`Unknown route source: ${source}`)
+    }
+  }
+
+  /**
+   * Execute AMM swap via precompile
+   */
+  private async executeAMMSwap(
+    quote: Quote,
+    recipient: Address,
+    deadline: number
+  ): Promise<SwapResult> {
+    // This would be called by the wallet/wagmi on the frontend
+    // Just return the transaction parameters
+    throw new Error('AMM swap execution should be handled by wagmi writeContract')
+  }
+
+  /**
+   * Execute CLOB swap
+   */
+  private async executeCLOBSwap(quote: Quote, recipient: Address): Promise<SwapResult> {
+    if (!this.clobClient) {
+      throw new Error('CLOB client not configured')
+    }
+
+    const step = quote.route[0]
+    if (!step?.symbol) {
+      throw new Error('Invalid CLOB route')
+    }
+
+    // Place market order on CLOB
+    const order = await this.clobClient.placeOrder({
+      symbol: step.symbol,
+      side: step.tokenIn.toLowerCase() < step.tokenOut.toLowerCase() ? 'buy' : 'sell',
+      type: 'market',
+      size: Number(quote.amountIn) / 1e18,
+    })
+
+    return {
+      txHash: `0x${order.orderId}` as `0x${string}`,
+      amountIn: quote.amountIn,
+      amountOut: quote.amountOut,
+      route: quote.route,
+    }
+  }
+}
+
+/**
+ * Create an omnichain router instance
+ */
+export function createRouter(config?: Partial<RouterConfig>): OmnichainRouter {
+  return new OmnichainRouter(config)
+}

package/src/router/types.ts

@@ -0,0 +1,87 @@
+/**
+ * Router Types
+ * Types for hybrid CLOB + AMM routing
+ */
+import type { Address } from 'viem'
+
+/**
+ * Route source - where liquidity comes from
+ */
+export type RouteSource = 'clob' | 'amm' | 'hybrid'
+
+/**
+ * Quote request
+ */
+export interface QuoteRequest {
+  tokenIn: Address
+  tokenOut: Address
+  amountIn: bigint
+  slippageTolerance?: number // basis points (default 50 = 0.5%)
+  preferredSource?: RouteSource
+}
+
+/**
+ * Route step
+ */
+export interface RouteStep {
+  source: RouteSource
+  tokenIn: Address
+  tokenOut: Address
+  amountIn: bigint
+  amountOut: bigint
+  pool?: Address // For AMM
+  symbol?: string // For CLOB
+  fee: bigint
+  priceImpact: number // basis points
+}
+
+/**
+ * Quote response
+ */
+export interface Quote {
+  tokenIn: Address
+  tokenOut: Address
+  amountIn: bigint
+  amountOut: bigint
+  minimumAmountOut: bigint
+  route: RouteStep[]
+  priceImpact: number // total price impact in basis points
+  estimatedGas: bigint
+  validUntil: number // timestamp
+}
+
+/**
+ * Swap request
+ */
+export interface SwapRequest {
+  quote: Quote
+  recipient: Address
+  deadline?: number
+}
+
+/**
+ * Swap result
+ */
+export interface SwapResult {
+  txHash: `0x${string}`
+  amountIn: bigint
+  amountOut: bigint
+  route: RouteStep[]
+}
+
+/**
+ * Router configuration
+ */
+export interface RouterConfig {
+  // CLOB connection
+  clobUrl?: string
+  clobEnabled?: boolean
+
+  // AMM configuration
+  ammEnabled?: boolean
+  maxHops?: number // max number of AMM hops
+
+  // Routing preferences
+  preferCLOB?: boolean // prefer CLOB for limit orders
+  hybridEnabled?: boolean // allow splitting between CLOB and AMM
+}