@luxfi/dex 1.2.1 → 2.0.0

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,29 @@
+/**
+ * LX Hooks Exports
+ * React hooks for DEX integration
+ *
+ * AMM (LP-9010):
+ * - useQuote, useSwap
+ *
+ * CLOB (LP-9020):
+ * - useLXBookL1, useLXBookPlaceOrder, useLXBookCancelOrder
+ *
+ * Vault (LP-9030):
+ * - useLXVault, useLXVaultPosition, useLXVaultMargin
+ *
+ * Feeds (LP-9040):
+ * - useLXFeedMarkPrice, useLXFeedFundingRate, useLXMarketPrices
+ */
+
+// AMM hooks
+export * from './use-quote'
+export * from './use-swap'
+
+// LXBook hooks (LP-9020) - CLOB trading
+export * from './use-lxbook'
+
+// LXVault hooks (LP-9030) - Custody and margin
+export * from './use-lxvault'
+
+// LXFeed hooks (LP-9040) - Price feeds
+export * from './use-lxfeed'