@luxfi/dex 1.2.1 → 1.3.0

package/package.json

@@ -1,41 +1,67 @@
 {
   "name": "@luxfi/dex",
-  "version": "1.2.1",
-  "description": "TypeScript SDK for LX",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "version": "1.3.0",
+  "description": "Lux DEX SDK - CLOB client, AMM precompiles, and omnichain routing",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client/index.d.ts",
+      "import": "./dist/client/index.js"
+    },
+    "./router": {
+      "types": "./dist/router/index.d.ts",
+      "import": "./dist/router/index.js"
+    },
+    "./precompile": {
+      "types": "./dist/precompile/index.d.ts",
+      "import": "./dist/precompile/index.js"
+    },
+    "./hooks": {
+      "types": "./dist/hooks/index.d.ts",
+      "import": "./dist/hooks/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
   "scripts": {
+    "typecheck": "tsc --noEmit",
     "build": "tsc",
-    "test": "jest",
-    "lint": "eslint src/**/*.ts",
-    "prepublish": "npm run build"
+    "prepublishOnly": "bun run build"
   },
-  "keywords": [
-    "luxfi",
-    "dex",
-    "trading",
-    "blockchain",
-    "sdk"
-  ],
-  "author": "Lux Network",
-  "license": "MIT",
   "dependencies": {
-    "axios": "^1.6.0",
-    "ws": "^8.14.0"
+    "viem": "^2.30.6",
+    "wagmi": "^3.1.3",
+    "zustand": "^5.0.5"
   },
   "devDependencies": {
-    "@types/jest": "^29.5.0",
-    "@types/node": "^20.0.0",
-    "@types/ws": "^8.5.0",
-    "@typescript-eslint/eslint-plugin": "^6.0.0",
-    "@typescript-eslint/parser": "^6.0.0",
-    "eslint": "^8.0.0",
-    "jest": "^29.5.0",
-    "ts-jest": "^29.1.0",
-    "typescript": "^5.0.0"
+    "@types/node": "^25.0.3",
+    "@types/react": "^19.2.3",
+    "typescript": "^5.8.3"
+  },
+  "peerDependencies": {
+    "react": "^19.0.0"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/luxfi/dex.git"
-  }
+    "url": "https://github.com/luxfi/exchange.git",
+    "directory": "packages/dex"
+  },
+  "keywords": [
+    "lux",
+    "dex",
+    "defi",
+    "clob",
+    "amm",
+    "swap",
+    "precompile"
+  ]
 }

package/src/client/clob.ts

@@ -0,0 +1,256 @@
+/**
+ * CLOB Client
+ * WebSocket client for lux/dex order book
+ */
+import type {
+  ICLOBClient,
+  OrderRequest,
+  Order,
+  OrderBook,
+  Trade,
+  Position,
+  Balance
+} from './types'
+
+interface CLOBClientOptions {
+  url: string
+  debug?: boolean
+  reconnect?: boolean
+  reconnectInterval?: number
+}
+
+type MessageHandler = (data: any) => void
+
+/**
+ * Central Limit Order Book client
+ * Connects to lux/dex WebSocket server
+ */
+export class CLOBClient implements ICLOBClient {
+  private ws: WebSocket | null = null
+  private url: string
+  private debug: boolean
+  private reconnect: boolean
+  private reconnectInterval: number
+  private connected: boolean = false
+  private authenticated: boolean = false
+  private requestId: number = 0
+  private pendingRequests: Map<number, { resolve: Function; reject: Function }> = new Map()
+  private subscriptions: Map<string, Set<MessageHandler>> = new Map()
+
+  constructor(options: CLOBClientOptions) {
+    this.url = options.url
+    this.debug = options.debug ?? false
+    this.reconnect = options.reconnect ?? true
+    this.reconnectInterval = options.reconnectInterval ?? 5000
+  }
+
+  private log(...args: any[]) {
+    if (this.debug) {
+      console.log('[CLOBClient]', ...args)
+    }
+  }
+
+  async connect(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      try {
+        this.ws = new WebSocket(this.url)
+
+        this.ws.onopen = () => {
+          this.connected = true
+          this.log('Connected to', this.url)
+          resolve()
+        }
+
+        this.ws.onclose = () => {
+          this.connected = false
+          this.authenticated = false
+          this.log('Disconnected')
+
+          if (this.reconnect) {
+            setTimeout(() => this.connect(), this.reconnectInterval)
+          }
+        }
+
+        this.ws.onerror = (error) => {
+          this.log('Error:', error)
+          reject(error)
+        }
+
+        this.ws.onmessage = (event) => {
+          this.handleMessage(event.data)
+        }
+      } catch (error) {
+        reject(error)
+      }
+    })
+  }
+
+  async disconnect(): Promise<void> {
+    this.reconnect = false
+    this.ws?.close()
+    this.ws = null
+    this.connected = false
+    this.authenticated = false
+  }
+
+  isConnected(): boolean {
+    return this.connected
+  }
+
+  private handleMessage(data: string) {
+    try {
+      const message = JSON.parse(data)
+      this.log('Received:', message)
+
+      // Handle response to request
+      if (message.id && this.pendingRequests.has(message.id)) {
+        const { resolve, reject } = this.pendingRequests.get(message.id)!
+        this.pendingRequests.delete(message.id)
+
+        if (message.error) {
+          reject(new Error(message.error))
+        } else {
+          resolve(message.result || message)
+        }
+        return
+      }
+
+      // Handle subscription updates
+      const type = message.type || message.channel
+      if (type && this.subscriptions.has(type)) {
+        this.subscriptions.get(type)!.forEach(handler => handler(message))
+      }
+    } catch (error) {
+      this.log('Parse error:', error)
+    }
+  }
+
+  private async request<T>(method: string, params?: any): Promise<T> {
+    if (!this.connected) {
+      throw new Error('Not connected')
+    }
+
+    const id = ++this.requestId
+    const message = {
+      jsonrpc: '2.0',
+      id,
+      method,
+      params,
+    }
+
+    return new Promise((resolve, reject) => {
+      this.pendingRequests.set(id, { resolve, reject })
+      this.ws!.send(JSON.stringify(message))
+      this.log('Sent:', message)
+
+      // Timeout after 30 seconds
+      setTimeout(() => {
+        if (this.pendingRequests.has(id)) {
+          this.pendingRequests.delete(id)
+          reject(new Error('Request timeout'))
+        }
+      }, 30000)
+    })
+  }
+
+  async authenticate(apiKey: string, apiSecret: string): Promise<void> {
+    await this.request('authenticate', { apiKey, apiSecret })
+    this.authenticated = true
+  }
+
+  async placeOrder(order: OrderRequest): Promise<Order> {
+    return this.request('placeOrder', order)
+  }
+
+  async cancelOrder(orderId: string): Promise<void> {
+    await this.request('cancelOrder', { orderId })
+  }
+
+  async getOrder(orderId: string): Promise<Order> {
+    return this.request('getOrder', { orderId })
+  }
+
+  async getOrders(symbol?: string): Promise<Order[]> {
+    return this.request('getOrders', { symbol })
+  }
+
+  async getOrderBook(symbol: string, depth: number = 20): Promise<OrderBook> {
+    return this.request('getOrderBook', { symbol, depth })
+  }
+
+  async getTrades(symbol: string, limit: number = 100): Promise<Trade[]> {
+    return this.request('getTrades', { symbol, limit })
+  }
+
+  async getPositions(): Promise<Position[]> {
+    return this.request('getPositions', {})
+  }
+
+  async getBalances(): Promise<Balance[]> {
+    return this.request('getBalances', {})
+  }
+
+  subscribeOrderBook(symbol: string, callback: (book: OrderBook) => void): () => void {
+    const channel = `orderbook:${symbol}`
+
+    if (!this.subscriptions.has(channel)) {
+      this.subscriptions.set(channel, new Set())
+      this.request('subscribe', { channel: 'orderbook', symbol }).catch(console.error)
+    }
+
+    this.subscriptions.get(channel)!.add(callback)
+
+    return () => {
+      this.subscriptions.get(channel)?.delete(callback)
+      if (this.subscriptions.get(channel)?.size === 0) {
+        this.subscriptions.delete(channel)
+        this.request('unsubscribe', { channel: 'orderbook', symbol }).catch(console.error)
+      }
+    }
+  }
+
+  subscribeTrades(symbol: string, callback: (trade: Trade) => void): () => void {
+    const channel = `trades:${symbol}`
+
+    if (!this.subscriptions.has(channel)) {
+      this.subscriptions.set(channel, new Set())
+      this.request('subscribe', { channel: 'trades', symbol }).catch(console.error)
+    }
+
+    this.subscriptions.get(channel)!.add(callback)
+
+    return () => {
+      this.subscriptions.get(channel)?.delete(callback)
+      if (this.subscriptions.get(channel)?.size === 0) {
+        this.subscriptions.delete(channel)
+        this.request('unsubscribe', { channel: 'trades', symbol }).catch(console.error)
+      }
+    }
+  }
+
+  subscribeOrders(callback: (order: Order) => void): () => void {
+    const channel = 'orders'
+
+    if (!this.subscriptions.has(channel)) {
+      this.subscriptions.set(channel, new Set())
+      this.request('subscribe', { channel: 'orders' }).catch(console.error)
+    }
+
+    this.subscriptions.get(channel)!.add(callback)
+
+    return () => {
+      this.subscriptions.get(channel)?.delete(callback)
+      if (this.subscriptions.get(channel)?.size === 0) {
+        this.subscriptions.delete(channel)
+        this.request('unsubscribe', { channel: 'orders' }).catch(console.error)
+      }
+    }
+  }
+}
+
+/**
+ * Create a CLOB client
+ */
+export function createCLOBClient(url: string, debug: boolean = false): ICLOBClient {
+  return new CLOBClient({ url, debug })
+}

package/src/client/index.ts

@@ -0,0 +1,6 @@
+/**
+ * DEX Client Exports
+ * CLOB client for lux/dex
+ */
+export * from './types'
+export * from './clob'

package/src/client/types.ts

@@ -0,0 +1,148 @@
+/**
+ * CLOB Client Types
+ * Interfaces for Central Limit Order Book operations
+ */
+
+/**
+ * Order side
+ */
+export type OrderSide = 'buy' | 'sell'
+
+/**
+ * Order type
+ */
+export type OrderType = 'limit' | 'market' | 'stop' | 'stop_limit'
+
+/**
+ * Order status
+ */
+export type OrderStatus = 'pending' | 'open' | 'partial' | 'filled' | 'cancelled' | 'rejected'
+
+/**
+ * Time in force
+ */
+export type TimeInForce = 'GTC' | 'IOC' | 'FOK' | 'GTD'
+
+/**
+ * Order request
+ */
+export interface OrderRequest {
+  symbol: string
+  side: OrderSide
+  type: OrderType
+  price?: number // Required for limit orders
+  size: number
+  timeInForce?: TimeInForce
+  clientOrderId?: string
+  reduceOnly?: boolean
+  postOnly?: boolean
+}
+
+/**
+ * Order response
+ */
+export interface Order {
+  orderId: string
+  clientOrderId?: string
+  symbol: string
+  side: OrderSide
+  type: OrderType
+  price: number
+  size: number
+  filledSize: number
+  remainingSize: number
+  status: OrderStatus
+  timeInForce: TimeInForce
+  createdAt: number
+  updatedAt: number
+}
+
+/**
+ * Order book entry
+ */
+export interface OrderBookEntry {
+  price: number
+  size: number
+  count: number
+}
+
+/**
+ * Order book
+ */
+export interface OrderBook {
+  symbol: string
+  bids: OrderBookEntry[]
+  asks: OrderBookEntry[]
+  timestamp: number
+}
+
+/**
+ * Trade
+ */
+export interface Trade {
+  tradeId: string
+  symbol: string
+  side: OrderSide
+  price: number
+  size: number
+  timestamp: number
+  makerOrderId: string
+  takerOrderId: string
+}
+
+/**
+ * Position
+ */
+export interface Position {
+  symbol: string
+  side: 'long' | 'short'
+  size: number
+  entryPrice: number
+  markPrice: number
+  liquidationPrice: number
+  unrealizedPnl: number
+  margin: number
+  leverage: number
+}
+
+/**
+ * Balance
+ */
+export interface Balance {
+  currency: string
+  available: number
+  locked: number
+  total: number
+}
+
+/**
+ * CLOB client interface
+ */
+export interface ICLOBClient {
+  // Connection
+  connect(): Promise<void>
+  disconnect(): Promise<void>
+  isConnected(): boolean
+
+  // Authentication
+  authenticate(apiKey: string, apiSecret: string): Promise<void>
+
+  // Orders
+  placeOrder(order: OrderRequest): Promise<Order>
+  cancelOrder(orderId: string): Promise<void>
+  getOrder(orderId: string): Promise<Order>
+  getOrders(symbol?: string): Promise<Order[]>
+
+  // Market data
+  getOrderBook(symbol: string, depth?: number): Promise<OrderBook>
+  getTrades(symbol: string, limit?: number): Promise<Trade[]>
+
+  // Account
+  getPositions(): Promise<Position[]>
+  getBalances(): Promise<Balance[]>
+
+  // Subscriptions
+  subscribeOrderBook(symbol: string, callback: (book: OrderBook) => void): () => void
+  subscribeTrades(symbol: string, callback: (trade: Trade) => void): () => void
+  subscribeOrders(callback: (order: Order) => void): () => void
+}

package/src/hooks/index.ts

@@ -0,0 +1,6 @@
+/**
+ * DEX Hooks Exports
+ * React hooks for DEX integration
+ */
+export * from './use-quote'
+export * from './use-swap'

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,
+  }
+}