@luxfi/dex 1.2.1

package/dist/marketData.js

@@ -0,0 +1,253 @@
+"use strict";
+/**
+ * Market data, liquidation, and settlement features for LX TypeScript SDK
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarketDataProviders = exports.LiquidationMonitor = exports.MarketDataClient = void 0;
+const ws_1 = __importDefault(require("ws"));
+class MarketDataClient {
+    constructor(jsonRpcClient) {
+        this.jsonRpc = jsonRpcClient;
+    }
+    /**
+     * Get market data from a specific source
+     */
+    async getMarketData(symbol, source) {
+        const result = await this.jsonRpc.call('market_data.get', {
+            symbol,
+            source
+        });
+        return {
+            name: result.name,
+            symbol: result.symbol,
+            price: result.price,
+            bid: result.bid,
+            ask: result.ask,
+            volume: result.volume,
+            latencyNs: result.latency_ns,
+            provider: result.provider
+        };
+    }
+    /**
+     * Get aggregated market data from all sources
+     */
+    async getAggregatedMarketData(symbol) {
+        const result = await this.jsonRpc.call('market_data.aggregate', {
+            symbol
+        });
+        return result.map((data) => ({
+            name: data.name,
+            symbol: data.symbol,
+            price: data.price,
+            bid: data.bid,
+            ask: data.ask,
+            volume: data.volume,
+            latencyNs: data.latency_ns,
+            provider: data.provider
+        }));
+    }
+    /**
+     * Get recent liquidations
+     */
+    async getLiquidations(symbol, limit = 100) {
+        const result = await this.jsonRpc.call('liquidations.get', {
+            symbol,
+            limit
+        });
+        return result.map((liq) => ({
+            userId: liq.user_id,
+            positionId: liq.position_id,
+            symbol: liq.symbol,
+            size: liq.size,
+            liquidationPrice: liq.liquidation_price,
+            markPrice: liq.mark_price,
+            status: liq.status,
+            timestamp: new Date(liq.timestamp)
+        }));
+    }
+    /**
+     * Get settlement batch information
+     */
+    async getSettlementBatch(batchId) {
+        const result = await this.jsonRpc.call('settlement.batch', {
+            batch_id: batchId
+        });
+        return {
+            batchId: result.batch_id,
+            orderIds: result.order_ids,
+            status: result.status,
+            txHash: result.tx_hash,
+            gasUsed: result.gas_used,
+            timestamp: new Date(result.timestamp)
+        };
+    }
+    /**
+     * Get margin information for a user
+     */
+    async getMarginInfo(userId) {
+        const result = await this.jsonRpc.call('margin.info', {
+            user_id: userId
+        });
+        return {
+            userId: result.user_id,
+            initialMargin: result.initial_margin,
+            maintenanceMargin: result.maintenance_margin,
+            marginRatio: result.margin_ratio,
+            freeMargin: result.free_margin,
+            marginLevel: result.margin_level
+        };
+    }
+    /**
+     * Check liquidation risk for a user
+     */
+    async checkLiquidationRisk(userId) {
+        const result = await this.jsonRpc.call('margin.liquidation_risk', {
+            user_id: userId
+        });
+        return {
+            userId: result.user_id,
+            riskLevel: result.risk_level,
+            marginLevel: result.margin_level,
+            liquidationPrice: result.liquidation_price,
+            timeToLiquidation: result.time_to_liquidation,
+            recommendations: result.recommendations || []
+        };
+    }
+    /**
+     * Get insurance fund status
+     */
+    async getInsuranceFundStatus() {
+        const result = await this.jsonRpc.call('insurance_fund.status');
+        return {
+            totalFund: result.total_fund,
+            availableFund: result.available_fund,
+            usedFund: result.used_fund,
+            pendingClaims: result.pending_claims,
+            lastUpdate: new Date(result.last_update)
+        };
+    }
+    /**
+     * Get list of available market data sources
+     */
+    async getMarketDataSources() {
+        return await this.jsonRpc.call('market_data.sources');
+    }
+    /**
+     * Get comprehensive market statistics
+     */
+    async getMarketStats(symbol) {
+        const result = await this.jsonRpc.call('market.stats', {
+            symbol
+        });
+        return {
+            symbol: result.symbol,
+            volume24h: result.volume_24h,
+            high24h: result.high_24h,
+            low24h: result.low_24h,
+            priceChange24h: result.price_change_24h,
+            priceChangePercent24h: result.price_change_percent_24h,
+            openInterest: result.open_interest,
+            fundingRate: result.funding_rate,
+            nextFundingTime: new Date(result.next_funding_time)
+        };
+    }
+}
+exports.MarketDataClient = MarketDataClient;
+class LiquidationMonitor {
+    constructor(wsConnection) {
+        this.callbacks = new Map();
+        this.ws = wsConnection;
+    }
+    /**
+     * Set WebSocket connection
+     */
+    setWebSocket(ws) {
+        this.ws = ws;
+    }
+    /**
+     * Subscribe to liquidation events
+     */
+    subscribeLiquidations(callback) {
+        if (!this.callbacks.has('liquidations')) {
+            this.callbacks.set('liquidations', []);
+        }
+        this.callbacks.get('liquidations').push(callback);
+        if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
+            this.ws.send(JSON.stringify({
+                type: 'subscribe',
+                channel: 'liquidations'
+            }));
+        }
+    }
+    /**
+     * Subscribe to settlement events
+     */
+    subscribeSettlements(callback) {
+        if (!this.callbacks.has('settlements')) {
+            this.callbacks.set('settlements', []);
+        }
+        this.callbacks.get('settlements').push(callback);
+        if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
+            this.ws.send(JSON.stringify({
+                type: 'subscribe',
+                channel: 'settlements'
+            }));
+        }
+    }
+    /**
+     * Subscribe to margin call events for a user
+     */
+    subscribeMarginCalls(userId, callback) {
+        const channel = `margin_calls:${userId}`;
+        if (!this.callbacks.has(channel)) {
+            this.callbacks.set(channel, []);
+        }
+        this.callbacks.get(channel).push(callback);
+        if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
+            this.ws.send(JSON.stringify({
+                type: 'subscribe',
+                channel
+            }));
+        }
+    }
+    /**
+     * Unsubscribe from a channel
+     */
+    unsubscribe(channel) {
+        this.callbacks.delete(channel);
+        if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
+            this.ws.send(JSON.stringify({
+                type: 'unsubscribe',
+                channel
+            }));
+        }
+    }
+    /**
+     * Handle incoming message
+     */
+    handleMessage(channel, data) {
+        const callbacks = this.callbacks.get(channel);
+        if (callbacks) {
+            callbacks.forEach(cb => cb(data));
+        }
+    }
+}
+exports.LiquidationMonitor = LiquidationMonitor;
+/**
+ * Market data sources supported by LX
+ */
+exports.MarketDataProviders = {
+    ALPACA: 'alpaca',
+    NYSE_ARCA: 'nyse_arca',
+    IEX_CLOUD: 'iex',
+    POLYGON: 'polygon',
+    CME_GROUP: 'cme',
+    REFINITIV: 'refinitiv',
+    ICE_DATA: 'ice',
+    BLOOMBERG: 'bloomberg',
+    NASDAQ_TOTALVIEW: 'nasdaq',
+    COINBASE_PRO: 'coinbase'
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@luxfi/dex",
+  "version": "1.2.1",
+  "description": "TypeScript SDK for LX",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "lint": "eslint src/**/*.ts",
+    "prepublish": "npm run build"
+  },
+  "keywords": [
+    "luxfi",
+    "dex",
+    "trading",
+    "blockchain",
+    "sdk"
+  ],
+  "author": "Lux Network",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.6.0",
+    "ws": "^8.14.0"
+  },
+  "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"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/luxfi/dex.git"
+  }
+}

package/src/index.ts

@@ -0,0 +1,309 @@
+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';