lighter-sdk-client 0.2.22

package/README.md

@@ -0,0 +1,816 @@
+# Lighter SDK Client
+
+Unofficial TypeScript/JavaScript SDK client for the Lighter protocol - a high-performance decentralized exchange built on zkSync.
+
+[![npm version](https://img.shields.io/npm/v/lighter-sdk-client.svg)](https://www.npmjs.com/package/lighter-sdk-client)
+[![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](https://opensource.org/licenses/ISC)
+
+## Features
+
+- 🔄 **Full API Coverage** - Complete access to public, private, and exchange endpoints
+- 🔐 **WASM Signing** - Built-in transaction signing with WebAssembly support
+- 🌉 **L1 Bridge Integration** - Direct integration with L1 bridging functionality
+- 📡 **WebSocket Support** - Real-time market data and account updates
+- 🎯 **TypeScript First** - Full type safety and IntelliSense support
+- 📋 **Protocol Constants** - Comprehensive enums and constants for type-safe interactions
+- ⚡ **High Performance** - Optimized for speed with minimal dependencies
+
+## Installation
+
+```bash
+pnpm add lighter-sdk-client
+```
+
+## Quick Start
+
+### Public API (InfoClient)
+
+Access public market data without authentication:
+
+```typescript
+import { InfoClient } from 'lighter-sdk-client';
+
+const client = new InfoClient({
+  baseURL: 'https://mainnet.zklighter.elliot.ai'
+});
+
+// Get account information
+const account = await client.getAccountInfo({ 
+  by: 'index', 
+  value: '0' 
+});
+
+// Get order books
+const orderBooks = await client.getOrderBooks();
+
+// Get asset details
+const allAssets = await client.getAssetDetails();
+const specificAsset = await client.getAssetDetails({ asset_index: 0 });
+
+// Get recent trades
+const trades = await client.getRecentTrades({
+  market_id: 1,
+  limit: 50
+});
+
+// Get candlestick data
+const candles = await client.getCandlesticks({
+  market_id: 1,
+  resolution: '1h',
+  start_timestamp: Math.floor(Date.now() / 1000) - 86400,
+  end_timestamp: Math.floor(Date.now() / 1000)
+});
+
+// Get withdrawal delay
+const withdrawalDelay = await client.getWithdrawalDelay();
+
+// Get root status
+const rootStatus = await client.getRootStatus();
+```
+
+### Exchange Operations (ExchangeClient)
+
+Send transactions and manage orders:
+
+```typescript
+import { ExchangeClient } from 'lighter-sdk-client';
+
+const client = new ExchangeClient({
+  baseURL: 'https://mainnet.zklighter.elliot.ai'
+});
+
+// Send a transaction
+const result = await client.sendTransaction({
+  account_index: 0,
+  api_key_index: 0,
+  transaction: '0x...'
+});
+
+// Send a batch of transactions
+const batchResult = await client.sendTransactionBatch({
+  account_index: 0,
+  api_key_index: 0,
+  transactions: ['0x...', '0x...']
+});
+
+// Change account tier
+const tierResult = await client.changeAccountTier({
+  account_index: 0,
+  new_tier: 'premium'
+}, 'auth-token');
+
+// Fast withdraw
+const withdrawResult = await client.fastWithdraw({
+  tx_info: '0x...',
+  to_address: '0x...'
+}, 'auth-token');
+
+// Create API token
+const newToken = await client.createToken({
+  name: 'My API Token',
+  account_index: 0,
+  expiry: Math.floor(Date.now() / 1000) + 86400 * 30, // 30 days
+  sub_account_access: true,
+  scopes: 'read.*'
+}, 'auth-token');
+
+// Revoke API token
+const revokeResult = await client.revokeToken({
+  token_id: 123,
+  account_index: 0
+}, 'auth-token');
+
+// Generate L1 sign message for changing public key
+const signMessage = await client.generateChangePubKeyL1SignMessage(
+  '0xabcdef...', // pubKeyHex
+  1, // nonce
+  0, // accountIndex
+  0  // newApiKeyIndex
+);
+console.log('Sign this message:', signMessage);
+```
+
+### Private API (InfoPrivateClient)
+
+Access authenticated account data with automatic WASM signing:
+
+```typescript
+import { InfoPrivateClient, WasmSigner } from 'lighter-sdk-client';
+
+// Initialize WASM signer
+const wasmSigner = new WasmSigner({
+  wasmPath: './public/wasm/lighter-signer.wasm',
+  wasmExecPath: './public/wasm/lighter-wasm-exec.js'
+});
+
+// Create private client - authentication is handled automatically
+const client = new InfoPrivateClient({
+  baseURL: 'https://mainnet.zklighter.elliot.ai',
+  wasmSigning: wasmSigner
+});
+
+// Get active orders
+const activeOrders = await client.getAccountActiveOrders({
+  account_index: 0,
+  market_id: 1
+});
+
+// Get inactive orders with pagination
+const inactiveOrders = await client.getAccountInactiveOrders({
+  account_index: 0,
+  limit: 50,
+  market_id: 1
+});
+
+// Get account limits and tier info
+const limits = await client.getAccountLimits({
+  account_index: 0
+});
+
+// Get L1 metadata
+const l1Metadata = await client.getL1Metadata({
+  l1_address: '0x...'
+});
+
+// Get API tokens for account
+const tokens = await client.getTokens({
+  account_index: 0
+});
+
+// Get deposit history
+const deposits = await client.getDepositHistory({
+  account_index: 0,
+  l1_address: '0x...',
+  filter: 'pending'
+});
+
+// Get withdrawal history
+const withdrawals = await client.getWithdrawHistory({
+  account_index: 0,
+  l1_address: '0x...',
+  filter: 'completed'
+});
+
+// Get fast withdraw information
+const fastWithdrawInfo = await client.getFastWithdrawInfo({
+  account_index: 0
+});
+
+// Get transfer fee information
+const transferFeeInfo = await client.getTransferFeeInfo({
+  account_index: 0,
+  to_account_index: 1
+});
+
+// Get transfer history
+const transfers = await client.getTransferHistory({
+  account_index: 0,
+  cursor: 'optional-cursor-for-pagination'
+});
+
+// Get liquidation history
+const liquidations = await client.getLiquidations({
+  account_index: 0,
+  limit: 50,
+  market_id: 1
+});
+
+// Get profit and loss data
+const pnl = await client.getPnL({
+  by: 'account_index',
+  value: '0',
+  resolution: '1d',
+  start_timestamp: Math.floor(Date.now() / 1000) - 86400 * 30,
+  end_timestamp: Math.floor(Date.now() / 1000),
+  count_back: 30
+});
+
+// Get position funding history
+const funding = await client.getPositionFunding({
+  account_index: 0,
+  limit: 50,
+  market_id: 1,
+  side: 'long'
+});
+
+// Get public pools metadata
+const pools = await client.getPublicPools({
+  filter: 'all',
+  limit: 10,
+  index: 0
+});
+
+// Get referral points
+const referralPoints = await client.getReferralPoints({
+  account_index: 0
+});
+
+// Get trades for account or market
+const trades = await client.getTrades({
+  sort_by: 'timestamp',
+  limit: 50,
+  account_index: 0,
+  market_id: 1,
+  sort_dir: 'desc'
+});
+
+// Export data
+const exportData = await client.getExport({
+  type: 'trade',
+  account_index: 0,
+  market_id: 1
+});
+console.log('Download URL:', exportData.data_url);
+```
+
+### L1 Bridge Operations
+
+Deposit and withdraw assets:
+
+```typescript
+import { L1BridgeClient } from 'lighter-sdk-client';
+import { arbitrum } from 'viem/chains';
+
+const bridgeClient = new L1BridgeClient({
+  chain: arbitrum,
+  l1RpcUrl: 'https://arb1.arbitrum.io/rpc',
+  privateKey: '0x...',
+  bridgeContractAddress: '0x...',
+  usdcAddress: '0x...'
+});
+
+// Deposit USDC from L1 to L2
+const result = await bridgeClient.depositUSDC({
+  amount: '100.00',
+  lighterAccountIndex: 0
+});
+
+console.log('Transaction hash:', result.transactionHash);
+console.log('Amount deposited:', result.amountDeposited);
+```
+
+### WebSocket Client
+
+Subscribe to real-time market data and account updates with automatic reconnection:
+
+```typescript
+import { WsClient } from 'lighter-sdk-client';
+
+const wsClient = new WsClient({
+  url: 'wss://mainnet.zklighter.elliot.ai/stream',
+  reconnectInterval: 5000,        // Initial reconnect delay (ms)
+  maxReconnectAttempts: Infinity, // Unlimited reconnection attempts
+  onOpen: () => console.log('WebSocket connected'),
+  onClose: () => console.log('WebSocket disconnected'),
+  onError: (error) => console.error('WebSocket error:', error),
+  onMessage: (data) => console.log('Raw message:', data)
+});
+
+// Connect to WebSocket server
+await wsClient.connect();
+
+// Subscribe to order book updates
+wsClient.subscribeOrderBook(1, (update) => {
+  console.log('Order book:', update.order_book);
+  console.log('Bids:', update.order_book.bids);
+  console.log('Asks:', update.order_book.asks);
+});
+
+// Subscribe to market statistics
+wsClient.subscribeMarketStats('all', (update) => {
+  console.log('Market stats:', update.market_stats);
+});
+
+// Subscribe to trade updates for a specific market
+wsClient.subscribeTrades(1, (update) => {
+  update.trades.forEach(trade => {
+    console.log('Trade:', {
+      price: trade.price,
+      size: trade.size,
+      side: trade.is_maker_ask ? 'sell' : 'buy'
+    });
+  });
+});
+
+// Subscribe to block height updates
+wsClient.subscribeHeight((update) => {
+  console.log('Current block height:', update.height);
+});
+
+// Subscribe to account updates (requires authentication)
+const authToken = 'your-auth-token';
+
+// Subscribe to all account data
+wsClient.subscribeAccountAll(0, (update) => {
+  console.log('Positions:', update.positions);
+  console.log('Orders:', update.trades);
+  console.log('Pool shares:', update.shares);
+});
+
+// Subscribe to specific market for an account
+wsClient.subscribeAccountMarket(1, 0, authToken, (update) => {
+  console.log('Account orders:', update.orders);
+  console.log('Account position:', update.position);
+  console.log('Account trades:', update.trades);
+});
+
+// Subscribe to user statistics
+wsClient.subscribeUserStats(0, (update) => {
+  console.log('Portfolio value:', update.stats.portfolio_value);
+  console.log('Available balance:', update.stats.available_balance);
+  console.log('Leverage:', update.stats.leverage);
+});
+
+// Subscribe to notifications
+wsClient.subscribeNotifications(0, authToken, (update) => {
+  update.notifs.forEach(notif => {
+    console.log('Notification:', notif.kind, notif.content);
+  });
+});
+
+// Unsubscribe from specific channels
+wsClient.unsubscribeOrderBook(1);
+wsClient.unsubscribeMarketStats('all');
+
+// Check connection status
+const isConnected = wsClient.isConnectedToWebSocket();
+console.log('Connected:', isConnected);
+
+// Get all active subscriptions
+const subscriptions = wsClient.getSubscriptions();
+console.log('Active subscriptions:', subscriptions);
+
+// Disconnect when done (stops automatic reconnection)
+wsClient.disconnect();
+```
+
+**Features:**
+- ✅ **Automatic Reconnection** - Uses `reconnecting-websocket` library for reliable connections
+- ✅ **Exponential Backoff** - Gradually increases reconnection delay (up to 30 seconds)
+- ✅ **Auto-Resubscription** - Automatically resubscribes to all channels after reconnection
+- ✅ **Type-Safe** - Full TypeScript support with typed update handlers
+- ✅ **Connection Management** - Built-in connection state tracking and lifecycle hooks
+
+## API Reference
+
+### InfoClient
+
+Public API client for market data and account information. No authentication required.
+
+#### Methods
+
+**Account Methods**
+- `getAccountInfo(params)` - Get account information by index or L2 address
+- `getAccountByL1Address(params)` - Get account information associated with an L1 address
+
+**API Keys & Announcements**
+- `getApiKeys(params)` - Get API keys for an account
+- `getAnnouncements()` - Get system announcements
+
+**Market Data**
+- `getAssetDetails(params?)` - Get asset details for a specific asset or all assets (symbol, decimals, limits, pricing)
+- `getCandlesticks(params)` - Get candlestick data with specified resolution and time range
+- `getFundings(params)` - Get funding history for a market
+- `getExchangeStats()` - Get exchange-wide statistics including volume and fees
+- `getFundingRates()` - Get current funding rates for all markets
+
+**Order Books**
+- `getOrderBooks()` - Get list of all order books with configurations
+- `getOrderBookDetails(params)` - Get detailed information about a specific order book
+- `getOrderBookOrders(params)` - Get bids and asks in an order book
+
+**Trades**
+- `getRecentTrades(params)` - Get recent trades for a market
+- `getTrades(params, authorization?)` - Get trades with optional filtering and authentication
+
+**Transactions**
+- `getTransaction(params)` - Get a specific transaction by hash
+- `getTransactions(params?)` - Get transactions with optional filtering
+- `getTransactionFromL1TxHash(params)` - Get L2 transaction from L1 transaction hash
+
+**Utilities**
+- `getNextNonce(params)` - Get the next nonce for an account
+- `getFastBridgeInfo()` - Get fast bridge configuration and status
+- `getWithdrawalDelay()` - Get withdrawal delay in seconds
+- `getRootStatus()` - Get root status information including network status and timestamp
+
+### ExchangeClient
+
+Client for sending transactions and managing exchange operations.
+
+#### Methods
+
+**Transaction Submission**
+- `sendTransaction(params)` - Send a signed transaction to the exchange
+- `sendTx(params)` - Send transaction with form data format
+- `sendTxWithIndices(params)` - Send transaction with account and API key indices
+- `sendTxJson(params)` - Send transaction with JSON payload format
+- `sendTransactionBatch(params)` - Send multiple transactions in a single batch for better efficiency
+
+**Account Management**
+- `changeAccountTier(params, authorization?)` - Change account tier (requires authorization)
+- `fastWithdraw(params, authorization?)` - Fast withdraw funds (requires authorization)
+
+**API Tokens**
+- `createToken(params, authorization?)` - Create API token with specified permissions and expiry
+- `revokeToken(params, authorization?)` - Revoke an existing API token
+- `generateChangePubKeyL1SignMessage(pubKeyHex, nonce, accountIndex, newApiKeyIndex)` - Generate L1 sign message for changing public key
+
+**Notifications**
+- `acknowledgeNotification(params)` - Acknowledge receipt of a notification
+
+### InfoPrivateClient
+
+Client for authenticated/private endpoints. Authentication is handled automatically via WasmSigner.
+
+#### Methods
+
+**Account Orders**
+- `getAccountActiveOrders(params)` - Get active orders for an account in a specific market
+- `getAccountInactiveOrders(params)` - Get inactive orders with pagination support
+
+**Account Information**
+- `getAccountLimits(params)` - Get account limits including max LLP percentage, user tier, and pool creation permissions
+- `getAccountMetadata(params)` - Get account metadata by index or L1 address
+- `getL1Metadata(params)` - Get L1 metadata for an address including referral information
+- `getTokens(params)` - Get API tokens for an account with details including name, expiry, scopes, and status
+
+**Transaction History**
+- `getDepositHistory(params)` - Get deposit history with status and timestamps
+- `getWithdrawHistory(params)` - Get withdrawal history with status and timestamps
+- `getFastWithdrawInfo(params)` - Get fast withdraw limits and account information
+- `getTransferFeeInfo(params)` - Get transfer fee information between accounts
+- `getTransferHistory(params)` - Get transfer history with pagination support
+- `getLiquidations(params)` - Get liquidation history with pagination support
+
+**Analytics**
+- `getPnL(params)` - Get profit and loss data with customizable resolution and time range
+- `getPositionFunding(params)` - Get position funding history with pagination support
+
+**Liquidity Pools**
+- `getPublicPools(params?)` - Get public pool information including TVL, APY, and share details
+
+**Referral System**
+- `getReferralPoints(params)` - Get referral points data including user points and referral list
+
+**Trading**
+- `getTrades(params)` - Get trades for an account or market with sorting and filtering options
+
+**Data Export**
+- `getExport(params)` - Export data (funding or trade data) for downloading
+
+### L1BridgeClient
+
+Client for L1 bridge operations to move assets between Layer 1 and Layer 2.
+
+#### Methods
+
+**Bridge Operations**
+- `depositUSDC(params)` - Deposit USDC from L1 to L2 Lighter account
+
+**Balance & Allowance**
+- `checkUSDCBalance()` - Check USDC balance on L1
+- `checkAllowance()` - Check current USDC allowance for bridge contract
+- `approveUSDC(amount)` - Approve USDC spending for bridge contract
+
+### WsClient
+
+WebSocket client for real-time market data and account updates with automatic reconnection and resubscription.
+
+#### Configuration Options
+
+```typescript
+interface WebSocketConfig {
+  url?: string;                    // WebSocket server URL (default: wss://mainnet.zklighter.elliot.ai/stream)
+  reconnectInterval?: number;      // Initial reconnect delay in ms (default: 5000)
+  maxReconnectAttempts?: number;   // Max reconnection attempts (default: Infinity)
+  onMessage?: (data: any) => void; // Raw message handler
+  onError?: (error: Error) => void; // Error handler
+  onClose?: () => void;            // Close event handler
+  onOpen?: () => void;             // Open event handler
+}
+```
+
+#### Methods
+
+**Connection Management**
+- `connect()` - Establish WebSocket connection with automatic reconnection support
+- `disconnect()` - Close WebSocket connection and stop automatic reconnection
+- `isConnectedToWebSocket()` - Check if currently connected to WebSocket server
+- `getSubscriptions()` - Get list of all active subscriptions
+
+**Market Data Subscriptions**
+- `subscribeOrderBook(marketIndex, handler)` - Subscribe to order book updates (bids/asks)
+- `unsubscribeOrderBook(marketIndex)` - Unsubscribe from order book updates
+- `subscribeTrades(marketIndex, handler)` - Subscribe to trade updates for a market
+- `unsubscribeTrades(marketIndex)` - Unsubscribe from trade updates
+- `subscribeMarketStats(market, handler)` - Subscribe to market statistics (market can be number or 'all')
+- `unsubscribeMarketStats(market)` - Unsubscribe from market statistics
+- `subscribeSpotMarketStats(market, handler)` - Subscribe to spot market statistics
+- `unsubscribeSpotMarketStats(market)` - Unsubscribe from spot market statistics
+
+**Account Subscriptions** (requires authentication)
+- `subscribeAccountAll(accountId, handler)` - Subscribe to all account data (positions, trades, shares)
+- `unsubscribeAccountAll(accountId)` - Unsubscribe from all account data
+- `subscribeAccountMarket(marketId, accountId, auth, handler)` - Subscribe to account updates for specific market
+- `unsubscribeAccountMarket(marketId, accountId)` - Unsubscribe from account market updates
+- `subscribeAccountOrders(marketIndex, accountId, auth, handler)` - Subscribe to order updates for specific market
+- `unsubscribeAccountOrders(marketIndex, accountId)` - Unsubscribe from order updates
+- `subscribeAccountAllOrders(accountId, auth, handler)` - Subscribe to all order updates across markets
+- `unsubscribeAccountAllOrders(accountId)` - Unsubscribe from all order updates
+- `subscribeAccountAllPositions(accountId, auth, handler)` - Subscribe to all position updates
+- `unsubscribeAccountAllPositions(accountId)` - Unsubscribe from position updates
+- `subscribeAccountAllTrades(accountId, auth, handler)` - Subscribe to all trade updates
+- `unsubscribeAccountAllTrades(accountId)` - Unsubscribe from trade updates
+- `subscribeUserStats(accountId, handler)` - Subscribe to user statistics (portfolio, balance, leverage)
+- `unsubscribeUserStats(accountId)` - Unsubscribe from user statistics
+
+**Pool Subscriptions** (requires authentication)
+- `subscribePoolData(accountId, auth, handler)` - Subscribe to pool data updates
+- `unsubscribePoolData(accountId)` - Unsubscribe from pool data
+- `subscribePoolInfo(accountId, auth, handler)` - Subscribe to pool information updates
+- `unsubscribePoolInfo(accountId)` - Unsubscribe from pool information
+
+**System Subscriptions**
+- `subscribeNotifications(accountId, auth, handler)` - Subscribe to system notifications
+- `unsubscribeNotifications(accountId)` - Unsubscribe from notifications
+- `subscribeTransactions(handler)` - Subscribe to all transaction updates
+- `unsubscribeTransactions()` - Unsubscribe from transaction updates
+- `subscribeExecutedTransactions(handler)` - Subscribe to executed transaction updates
+- `unsubscribeExecutedTransactions()` - Unsubscribe from executed transactions
+- `subscribeAccountTransactions(accountId, auth, handler)` - Subscribe to account-specific transactions
+- `unsubscribeAccountTransactions(accountId)` - Unsubscribe from account transactions
+- `subscribeHeight(handler)` - Subscribe to block height updates
+- `unsubscribeHeight()` - Unsubscribe from height updates
+
+**Advanced**
+- `subscribe<TPayload>(subscription)` - Generic subscribe method with custom subscription options
+- `unsubscribe(channel)` - Generic unsubscribe method for any channel
+- `send(message)` - Send raw message through WebSocket connection
+
+## Constants and Enums
+
+The SDK provides comprehensive constants and enums for type-safe interaction with the Lighter protocol:
+
+### Transaction Types
+
+```typescript
+import { TxType } from 'lighter-sdk-client';
+
+// L1 Transaction Types
+TxType.L1Deposit
+TxType.L1ChangePubKey
+TxType.L1CreateMarket
+TxType.L1UpdateMarket
+TxType.L1CancelAllOrders
+TxType.L1Withdraw
+TxType.L1CreateOrder
+TxType.L1BurnShares
+
+// L2 Transaction Types
+TxType.L2ChangePubKey
+TxType.L2CreateSubAccount
+TxType.L2CreatePublicPool
+TxType.L2UpdatePublicPool
+TxType.L2Transfer
+TxType.L2Withdraw
+TxType.L2CreateOrder
+TxType.L2CancelOrder
+TxType.L2CancelAllOrders
+TxType.L2ModifyOrder
+TxType.L2MintShares
+TxType.L2BurnShares
+TxType.L2UpdateLeverage
+TxType.L2CreateGroupedOrders
+TxType.L2UpdateMargin
+
+// Internal Transaction Types
+TxType.InternalClaimOrder
+TxType.InternalCancelOrder
+TxType.InternalDeleverage
+TxType.InternalExitPosition
+TxType.InternalCancelAllOrders
+TxType.InternalLiquidatePosition
+TxType.InternalCreateOrder
+```
+
+### Order Types
+
+```typescript
+import { OrderType } from 'lighter-sdk-client';
+
+OrderType.Limit           // Standard limit order
+OrderType.Market          // Market order
+OrderType.StopLoss        // Stop loss order
+OrderType.StopLossLimit   // Stop loss limit order
+OrderType.TakeProfit      // Take profit order
+OrderType.TakeProfitLimit // Take profit limit order
+OrderType.TWAP            // Time-weighted average price order
+OrderType.TWAPSub         // TWAP sub-order (internal)
+OrderType.Liquidation     // Liquidation order (internal)
+```
+
+### Order Time-In-Force
+
+```typescript
+import { OrderTimeInForce } from 'lighter-sdk-client';
+
+OrderTimeInForce.ImmediateOrCancel // Execute immediately or cancel
+OrderTimeInForce.GoodTillTime      // Active until specified time
+OrderTimeInForce.PostOnly          // Only add to order book (maker only)
+```
+
+### Grouping Types
+
+```typescript
+import { GroupingType } from 'lighter-sdk-client';
+
+GroupingType.Default                        // No grouping
+GroupingType.OneTriggersTheOther           // OCO: One triggers the other
+GroupingType.OneCancelsTheOther            // OCO: One cancels the other
+GroupingType.OneTriggersAOneCancelsTheOther // OTOCO: Combined behavior
+```
+
+### Margin Modes
+
+```typescript
+import { 
+  PositionMarginMode, 
+  AssetMarginMode,
+  MarginUpdateDirection 
+} from 'lighter-sdk-client';
+
+// Position Margin Mode
+PositionMarginMode.Cross    // Cross margin
+PositionMarginMode.Isolated // Isolated margin
+
+// Asset Margin Mode
+AssetMarginMode.Disabled
+AssetMarginMode.Enabled
+
+// Margin Update Direction
+MarginUpdateDirection.RemoveFromIsolated
+MarginUpdateDirection.AddToIsolated
+```
+
+### Asset Route Types
+
+```typescript
+import { AssetRouteType } from 'lighter-sdk-client';
+
+AssetRouteType.Perps // Perpetual futures
+AssetRouteType.Spot  // Spot trading
+```
+
+### Numeric Constants
+
+The SDK includes various numeric constants for limits and validations:
+
+```typescript
+import { 
+  OneUSDC,
+  MinOrderPrice,
+  MaxOrderPrice,
+  MinOrderBaseAmount,
+  MaxOrderBaseAmount,
+  MinAccountIndex,
+  MaxAccountIndex,
+  NativeAssetIndex,
+  USDCAssetIndex,
+  // ... and many more
+} from 'lighter-sdk-client';
+
+// Example usage
+const minAmount = MinOrderBaseAmount; // 1
+const maxAmount = MaxOrderBaseAmount; // 281474976710655
+const usdcDecimals = OneUSDC;         // 1000000
+```
+
+Available numeric constants include:
+- **Account Indices**: `MinAccountIndex`, `MaxAccountIndex`, `MaxMasterAccountIndex`, `MinSubAccountIndex`
+- **Market Indices**: `MinMarketIndex`, `MaxPerpsMarketIndex`, `MinSpotMarketIndex`, `MaxSpotMarketIndex`
+- **Asset Indices**: `NativeAssetIndex`, `USDCAssetIndex`, `MinAssetIndex`, `MaxAssetIndex`
+- **Order Limits**: `MinOrderPrice`, `MaxOrderPrice`, `MinOrderBaseAmount`, `MaxOrderBaseAmount`
+- **Order Timing**: `MinOrderExpiryPeriod`, `MaxOrderExpiryPeriod`, `MinOrderCancelAllPeriod`, `MaxOrderCancelAllPeriod`
+- **Pool Limits**: `MaxInvestedPublicPoolCount`, `MinInitialTotalShares`, `MaxInitialTotalShares`
+- **Exchange Limits**: `MaxExchangeUSDC`, `MinTransferAmount`, `MaxTransferAmount`, `MinWithdrawalAmount`, `MaxWithdrawalAmount`
+
+## Configuration
+
+### Base URLs
+
+- **Mainnet**: `https://mainnet.zklighter.elliot.ai`
+- **WebSocket**: `wss://mainnet.zklighter.elliot.ai/stream`
+
+### WASM Signing Setup
+
+For transaction signing, you need to include the WASM files (please copy them from the `lighter-sdk-client` package to your `./public` directory):
+
+```typescript
+import { WasmSigner } from 'lighter-sdk-client';
+
+const wasmSigning = new WasmSigner({
+  wasmPath: './public/wasm/lighter-signer.wasm',
+  wasmExecPath: './public/wasm/lighter-wasm-exec.js'
+});
+```
+
+The WASM files should be placed in your public directory and served statically.
+
+## Dependencies
+
+- `axios` - HTTP client for API requests
+- `viem` - Ethereum library for L1 bridge operations
+- `wagmi` - React hooks for Ethereum (peer dependency)
+- `@tanstack/react-query` - Data fetching library (peer dependency)
+
+## Development
+
+### Build
+
+```bash
+pnpm build
+```
+
+### Project Structure
+
+```
+src/
+├── api/              # API endpoint implementations
+│   ├── exchange/     # Exchange/transaction endpoints
+│   ├── info/         # Public info endpoints
+│   └── info-private/ # Private/authenticated endpoints
+├── client/           # Client classes
+│   ├── exchange-client.ts
+│   ├── info-client.ts
+│   ├── info-private-client.ts
+│   ├── l1-bridge-client.ts
+│   └── ws-client.ts
+├── signing/          # Transaction signing utilities
+│   └── wasm-signer.ts
+└── types/            # TypeScript type definitions
+    ├── bridge.ts
+    ├── constant.ts   # Protocol constants and enums
+    ├── ws.ts
+    └── index.ts
+```
+
+## License
+
+ISC
+
+## Disclaimer
+
+This is an unofficial SDK client for the Lighter protocol. Use at your own risk. Always verify transactions before signing.
+
+## Links
+
+- [Lighter Protocol](https://lighter.xyz)
+- [Documentation](https://docs.lighter.xyz)
+
+## Support
+
+For issues and questions:
+- Create an issue on GitHub
+- Join the Lighter community Discord
+- Check the official documentation