@luxfi/dex 1.2.1 → 1.3.0

package/src/index.ts

@@ -1,309 +1,76 @@
-import axios, { AxiosInstance } from 'axios';
-import WebSocket from 'ws';
-import { 
-  MarketDataClient, 
-  LiquidationMonitor,
-  MarketDataSource,
-  LiquidationInfo,
-  SettlementBatch,
-  MarginInfo,
-  MarketDataProviders
-} from './marketData';
-
-// Types
-export enum OrderType {
-  LIMIT = 0,
-  MARKET = 1,
-  STOP = 2,
-  STOP_LIMIT = 3,
-  ICEBERG = 4,
-  PEG = 5
-}
-
-export enum OrderSide {
-  BUY = 0,
-  SELL = 1
-}
-
-export enum OrderStatus {
-  OPEN = 'open',
-  PARTIAL = 'partial',
-  FILLED = 'filled',
-  CANCELLED = 'cancelled',
-  REJECTED = 'rejected'
-}
-
-export enum TimeInForce {
-  GTC = 'GTC',
-  IOC = 'IOC',
-  FOK = 'FOK',
-  DAY = 'DAY'
-}
-
-export interface Order {
-  orderId?: number;
-  symbol: string;
-  type: OrderType;
-  side: OrderSide;
-  price: number;
-  size: number;
-  userID?: string;
-  clientID?: string;
-  timeInForce?: TimeInForce;
-  postOnly?: boolean;
-  reduceOnly?: boolean;
-  status?: OrderStatus;
-  filled?: number;
-  remaining?: number;
-  timestamp?: number;
-}
-
-export interface Trade {
-  tradeId: number;
-  symbol: string;
-  price: number;
-  size: number;
-  side: OrderSide;
-  buyOrderId: number;
-  sellOrderId: number;
-  buyerId: string;
-  sellerId: string;
-  timestamp: number;
-}
-
-export interface OrderBookLevel {
-  price: number;
-  size: number;
-  count?: number;
-}
-
-export interface OrderBook {
-  symbol: string;
-  bids: OrderBookLevel[];
-  asks: OrderBookLevel[];
-  timestamp: number;
-}
-
-export interface NodeInfo {
-  version: string;
-  network: string;
-  orderCount: number;
-  tradeCount: number;
-  timestamp: number;
-}
-
-export interface LXDexConfig {
-  jsonRpcUrl?: string;
-  wsUrl?: string;
-  grpcUrl?: string;
-  apiKey?: string;
-}
-
-// JSON-RPC Client
-class JSONRPCClient {
-  private axios: AxiosInstance;
-  private idCounter = 1;
-
-  constructor(baseURL: string) {
-    this.axios = axios.create({
-      baseURL,
-      headers: {
-        'Content-Type': 'application/json'
-      }
-    });
-  }
-
-  async call(method: string, params: any = {}): Promise<any> {
-    const response = await this.axios.post('/rpc', {
-      jsonrpc: '2.0',
-      method,
-      params,
-      id: this.idCounter++
-    });
-
-    if (response.data.error) {
-      throw new Error(response.data.error.message);
-    }
-
-    return response.data.result;
-  }
-}
-
-// Main SDK Client
-export class LXDexClient {
-  private jsonRpc: JSONRPCClient;
-  private ws: WebSocket | null = null;
-  private wsCallbacks: Map<string, Function[]> = new Map();
-  private config: LXDexConfig;
-  public marketData: MarketDataClient;
-  public liquidationMonitor: LiquidationMonitor;
-
-  constructor(config: LXDexConfig = {}) {
-    this.config = {
-      jsonRpcUrl: config.jsonRpcUrl || 'http://localhost:8080',
-      wsUrl: config.wsUrl || 'ws://localhost:8081',
-      ...config
-    };
-
-    this.jsonRpc = new JSONRPCClient(this.config.jsonRpcUrl!);
-    
-    // Initialize sub-clients
-    this.marketData = new MarketDataClient(this.jsonRpc);
-    this.liquidationMonitor = new LiquidationMonitor(null);
-  }
-
-  // Connection Management
-  async connect(): Promise<void> {
-    if (this.ws) return;
-
-    return new Promise((resolve, reject) => {
-      this.ws = new WebSocket(this.config.wsUrl!);
-
-      this.ws.on('open', () => {
-        console.log('WebSocket connected');
-        // Set WebSocket for liquidation monitor
-        this.liquidationMonitor.setWebSocket(this.ws!);
-        resolve();
-      });
-
-      this.ws.on('message', (data: string) => {
-        try {
-          const msg = JSON.parse(data);
-          this.handleWebSocketMessage(msg);
-        } catch (err) {
-          console.error('Failed to parse WebSocket message:', err);
-        }
-      });
-
-      this.ws.on('error', (err) => {
-        console.error('WebSocket error:', err);
-        reject(err);
-      });
-
-      this.ws.on('close', () => {
-        console.log('WebSocket disconnected');
-        this.ws = null;
-      });
-    });
-  }
-
-  disconnect(): void {
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-  }
-
-  // Order Management
-  async placeOrder(order: Partial<Order>): Promise<{ orderId: number; status: string }> {
-    return this.jsonRpc.call('lx_placeOrder', order);
-  }
-
-  async cancelOrder(orderId: number): Promise<{ success: boolean; message: string }> {
-    return this.jsonRpc.call('lx_cancelOrder', { orderId });
-  }
-
-  async getOrder(orderId: number): Promise<Order> {
-    return this.jsonRpc.call('lx_getOrder', { orderId });
-  }
-
-  // Market Data
-  async getOrderBook(symbol: string = 'BTC-USD', depth: number = 10): Promise<OrderBook> {
-    return this.jsonRpc.call('lx_getOrderBook', { symbol, depth });
-  }
-
-  async getBestBid(symbol: string = 'BTC-USD'): Promise<number> {
-    const result = await this.jsonRpc.call('lx_getBestBid', { symbol });
-    return result.price;
-  }
-
-  async getBestAsk(symbol: string = 'BTC-USD'): Promise<number> {
-    const result = await this.jsonRpc.call('lx_getBestAsk', { symbol });
-    return result.price;
-  }
-
-  async getTrades(symbol: string = 'BTC-USD', limit: number = 100): Promise<Trade[]> {
-    return this.jsonRpc.call('lx_getTrades', { symbol, limit });
-  }
-
-  // Node Information
-  async getInfo(): Promise<NodeInfo> {
-    return this.jsonRpc.call('lx_getInfo');
-  }
-
-  async ping(): Promise<string> {
-    return this.jsonRpc.call('lx_ping');
-  }
-
-  // WebSocket Subscriptions
-  subscribe(channel: string, callback: Function): void {
-    if (!this.wsCallbacks.has(channel)) {
-      this.wsCallbacks.set(channel, []);
-    }
-    this.wsCallbacks.get(channel)!.push(callback);
-
-    // Send subscription message
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      this.ws.send(JSON.stringify({
-        type: 'subscribe',
-        channel
-      }));
-    }
-  }
-
-  unsubscribe(channel: string, callback?: Function): void {
-    if (callback) {
-      const callbacks = this.wsCallbacks.get(channel);
-      if (callbacks) {
-        const index = callbacks.indexOf(callback);
-        if (index > -1) {
-          callbacks.splice(index, 1);
-        }
-      }
-    } else {
-      this.wsCallbacks.delete(channel);
-    }
-
-    // Send unsubscribe message
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      this.ws.send(JSON.stringify({
-        type: 'unsubscribe',
-        channel
-      }));
-    }
-  }
-
-  subscribeOrderBook(symbol: string, callback: (book: OrderBook) => void): void {
-    this.subscribe(`orderbook:${symbol}`, callback);
-  }
-
-  subscribeTrades(symbol: string, callback: (trade: Trade) => void): void {
-    this.subscribe(`trades:${symbol}`, callback);
-  }
-
-  // Private methods
-  private handleWebSocketMessage(msg: any): void {
-    const { channel, data } = msg;
-    const callbacks = this.wsCallbacks.get(channel);
-    if (callbacks) {
-      callbacks.forEach(cb => cb(data));
-    }
-  }
-
-  // Utility methods
-  static formatPrice(price: number, decimals: number = 2): string {
-    return price.toFixed(decimals);
-  }
-
-  static formatSize(size: number, decimals: number = 8): string {
-    return size.toFixed(decimals);
-  }
-
-  static calculateTotal(price: number, size: number): number {
-    return price * size;
-  }
-}
-
-// Export everything
-export default LXDexClient;
-export * from './marketData';
+/**
+ * @luxfi/dex
+ *
+ * DEX Integration Package
+ *
+ * Provides routing between:
+ * - CLOB (Central Limit Order Book) via ~/work/lux/dex
+ * - AMM Precompiles (0x0400-0x0403) for native swaps
+ *
+ * Architecture:
+ * ```
+ * ┌────────────────────────────────────────┐
+ * │           Omnichain Router             │
+ * │  Best execution between CLOB & AMM     │
+ * └─────────────────┬──────────────────────┘
+ *                   │
+ *     ┌─────────────┴─────────────┐
+ *     │                           │
+ *     ▼                           ▼
+ * ┌─────────┐              ┌───────────────┐
+ * │  CLOB   │              │ AMM Precompile│
+ * │ Client  │              │   (0x0400)    │
+ * │         │              │               │
+ * │ • Limit │              │ • Swap        │
+ * │ • HFT   │              │ • Liquidity   │
+ * │ • Perps │              │ • Flash       │
+ * └─────────┘              └───────────────┘
+ * ```
+ */
+
+// Precompile types and ABIs (AMM)
+export {
+  // Types
+  type Currency,
+  type PoolKey,
+  type BalanceDelta,
+  type SwapParams,
+  type ModifyLiquidityParams,
+  type PoolState,
+  type Position as AMMPosition,
+  NATIVE_LUX,
+  sortCurrencies,
+  createPoolKey,
+  // ABIs
+  POOL_MANAGER_ABI,
+  SWAP_ROUTER_ABI,
+  HOOKS_REGISTRY_ABI,
+  FLASH_LOAN_ABI,
+  // Addresses
+  DEX_PRECOMPILES,
+  type DexPrecompile,
+} from './precompile'
+
+// CLOB client (exports Position as CLOBPosition to avoid conflict)
+export {
+  type OrderSide,
+  type OrderType,
+  type OrderStatus,
+  type TimeInForce,
+  type OrderRequest,
+  type Order,
+  type OrderBookEntry,
+  type OrderBook,
+  type Trade,
+  type Position as CLOBPosition,
+  type Balance,
+  type ICLOBClient,
+  CLOBClient,
+  createCLOBClient,
+} from './client'
+
+// Omnichain router
+export * from './router'
+
+// React hooks
+export * from './hooks'

package/src/precompile/abis.ts

@@ -0,0 +1,291 @@
+/**
+ * DEX Precompile ABIs
+ * Native Go implementation at 0x0400-0x0403
+ */
+
+/**
+ * PoolManager ABI (0x0400)
+ * Singleton contract managing all pools
+ */
+export const POOL_MANAGER_ABI = [
+  // Initialize a new pool
+  {
+    type: 'function',
+    name: 'initialize',
+    inputs: [
+      {
+        name: 'key',
+        type: 'tuple',
+        components: [
+          { name: 'currency0', type: 'address' },
+          { name: 'currency1', type: 'address' },
+          { name: 'fee', type: 'uint24' },
+          { name: 'tickSpacing', type: 'int24' },
+          { name: 'hooks', type: 'address' },
+        ],
+      },
+      { name: 'sqrtPriceX96', type: 'uint160' },
+    ],
+    outputs: [{ name: 'tick', type: 'int24' }],
+    stateMutability: 'nonpayable',
+  },
+  // Execute a swap
+  {
+    type: 'function',
+    name: 'swap',
+    inputs: [
+      {
+        name: 'key',
+        type: 'tuple',
+        components: [
+          { name: 'currency0', type: 'address' },
+          { name: 'currency1', type: 'address' },
+          { name: 'fee', type: 'uint24' },
+          { name: 'tickSpacing', type: 'int24' },
+          { name: 'hooks', type: 'address' },
+        ],
+      },
+      {
+        name: 'params',
+        type: 'tuple',
+        components: [
+          { name: 'zeroForOne', type: 'bool' },
+          { name: 'amountSpecified', type: 'int256' },
+          { name: 'sqrtPriceLimitX96', type: 'uint160' },
+        ],
+      },
+      { name: 'hookData', type: 'bytes' },
+    ],
+    outputs: [{ name: 'delta', type: 'int256' }],
+    stateMutability: 'nonpayable',
+  },
+  // Modify liquidity
+  {
+    type: 'function',
+    name: 'modifyLiquidity',
+    inputs: [
+      {
+        name: 'key',
+        type: 'tuple',
+        components: [
+          { name: 'currency0', type: 'address' },
+          { name: 'currency1', type: 'address' },
+          { name: 'fee', type: 'uint24' },
+          { name: 'tickSpacing', type: 'int24' },
+          { name: 'hooks', type: 'address' },
+        ],
+      },
+      {
+        name: 'params',
+        type: 'tuple',
+        components: [
+          { name: 'tickLower', type: 'int24' },
+          { name: 'tickUpper', type: 'int24' },
+          { name: 'liquidityDelta', type: 'int256' },
+          { name: 'salt', type: 'bytes32' },
+        ],
+      },
+      { name: 'hookData', type: 'bytes' },
+    ],
+    outputs: [
+      { name: 'callerDelta', type: 'int256' },
+      { name: 'feesAccrued', type: 'int256' },
+    ],
+    stateMutability: 'nonpayable',
+  },
+  // Settle outstanding balance
+  {
+    type: 'function',
+    name: 'settle',
+    inputs: [{ name: 'currency', type: 'address' }],
+    outputs: [{ name: 'amount', type: 'uint256' }],
+    stateMutability: 'payable',
+  },
+  // Take tokens from pool
+  {
+    type: 'function',
+    name: 'take',
+    inputs: [
+      { name: 'currency', type: 'address' },
+      { name: 'to', type: 'address' },
+      { name: 'amount', type: 'uint256' },
+    ],
+    outputs: [],
+    stateMutability: 'nonpayable',
+  },
+  // Get pool state
+  {
+    type: 'function',
+    name: 'getSlot0',
+    inputs: [
+      {
+        name: 'key',
+        type: 'tuple',
+        components: [
+          { name: 'currency0', type: 'address' },
+          { name: 'currency1', type: 'address' },
+          { name: 'fee', type: 'uint24' },
+          { name: 'tickSpacing', type: 'int24' },
+          { name: 'hooks', type: 'address' },
+        ],
+      },
+    ],
+    outputs: [
+      { name: 'sqrtPriceX96', type: 'uint160' },
+      { name: 'tick', type: 'int24' },
+      { name: 'protocolFee', type: 'uint24' },
+      { name: 'lpFee', type: 'uint24' },
+    ],
+    stateMutability: 'view',
+  },
+  // Get liquidity
+  {
+    type: 'function',
+    name: 'getLiquidity',
+    inputs: [
+      {
+        name: 'key',
+        type: 'tuple',
+        components: [
+          { name: 'currency0', type: 'address' },
+          { name: 'currency1', type: 'address' },
+          { name: 'fee', type: 'uint24' },
+          { name: 'tickSpacing', type: 'int24' },
+          { name: 'hooks', type: 'address' },
+        ],
+      },
+    ],
+    outputs: [{ name: 'liquidity', type: 'uint128' }],
+    stateMutability: 'view',
+  },
+] as const
+
+/**
+ * SwapRouter ABI (0x0401)
+ * Optimized swap routing
+ */
+export const SWAP_ROUTER_ABI = [
+  // Single swap (exact input)
+  {
+    type: 'function',
+    name: 'exactInputSingle',
+    inputs: [
+      {
+        name: 'params',
+        type: 'tuple',
+        components: [
+          {
+            name: 'poolKey',
+            type: 'tuple',
+            components: [
+              { name: 'currency0', type: 'address' },
+              { name: 'currency1', type: 'address' },
+              { name: 'fee', type: 'uint24' },
+              { name: 'tickSpacing', type: 'int24' },
+              { name: 'hooks', type: 'address' },
+            ],
+          },
+          { name: 'zeroForOne', type: 'bool' },
+          { name: 'amountIn', type: 'uint256' },
+          { name: 'amountOutMinimum', type: 'uint256' },
+          { name: 'sqrtPriceLimitX96', type: 'uint160' },
+          { name: 'hookData', type: 'bytes' },
+        ],
+      },
+    ],
+    outputs: [{ name: 'amountOut', type: 'uint256' }],
+    stateMutability: 'payable',
+  },
+  // Single swap (exact output)
+  {
+    type: 'function',
+    name: 'exactOutputSingle',
+    inputs: [
+      {
+        name: 'params',
+        type: 'tuple',
+        components: [
+          {
+            name: 'poolKey',
+            type: 'tuple',
+            components: [
+              { name: 'currency0', type: 'address' },
+              { name: 'currency1', type: 'address' },
+              { name: 'fee', type: 'uint24' },
+              { name: 'tickSpacing', type: 'int24' },
+              { name: 'hooks', type: 'address' },
+            ],
+          },
+          { name: 'zeroForOne', type: 'bool' },
+          { name: 'amountOut', type: 'uint256' },
+          { name: 'amountInMaximum', type: 'uint256' },
+          { name: 'sqrtPriceLimitX96', type: 'uint160' },
+          { name: 'hookData', type: 'bytes' },
+        ],
+      },
+    ],
+    outputs: [{ name: 'amountIn', type: 'uint256' }],
+    stateMutability: 'payable',
+  },
+  // Multi-hop swap
+  {
+    type: 'function',
+    name: 'exactInput',
+    inputs: [
+      {
+        name: 'params',
+        type: 'tuple',
+        components: [
+          { name: 'path', type: 'bytes' },
+          { name: 'amountIn', type: 'uint256' },
+          { name: 'amountOutMinimum', type: 'uint256' },
+        ],
+      },
+    ],
+    outputs: [{ name: 'amountOut', type: 'uint256' }],
+    stateMutability: 'payable',
+  },
+] as const
+
+/**
+ * HooksRegistry ABI (0x0402)
+ * Registry for hook contracts
+ */
+export const HOOKS_REGISTRY_ABI = [
+  {
+    type: 'function',
+    name: 'registerHook',
+    inputs: [
+      { name: 'hook', type: 'address' },
+      { name: 'permissions', type: 'uint256' },
+    ],
+    outputs: [],
+    stateMutability: 'nonpayable',
+  },
+  {
+    type: 'function',
+    name: 'getHookPermissions',
+    inputs: [{ name: 'hook', type: 'address' }],
+    outputs: [{ name: 'permissions', type: 'uint256' }],
+    stateMutability: 'view',
+  },
+] as const
+
+/**
+ * FlashLoan ABI (0x0403)
+ * Flash loan facility
+ */
+export const FLASH_LOAN_ABI = [
+  {
+    type: 'function',
+    name: 'flash',
+    inputs: [
+      { name: 'recipient', type: 'address' },
+      { name: 'currency', type: 'address' },
+      { name: 'amount', type: 'uint256' },
+      { name: 'data', type: 'bytes' },
+    ],
+    outputs: [],
+    stateMutability: 'nonpayable',
+  },
+] as const