@0xarchive/sdk 0.9.2 → 1.3.0

package/dist/index.d.ts

@@ -464,10 +464,11 @@ interface PriceHistoryParams extends CursorPaginationParams {
  *
  * - ticker/all_tickers: real-time only
  * - liquidations: historical only (May 2025+)
+ * - hip3_liquidations: historical only (Feb 2026+)
  * - open_interest, funding, lighter_open_interest, lighter_funding,
  *   hip3_open_interest, hip3_funding: historical only (replay/stream)
  */
-type WsChannel = 'orderbook' | 'trades' | 'candles' | 'liquidations' | 'ticker' | 'all_tickers' | 'open_interest' | 'funding' | 'lighter_orderbook' | 'lighter_trades' | 'lighter_candles' | 'lighter_open_interest' | 'lighter_funding' | 'hip3_orderbook' | 'hip3_trades' | 'hip3_candles' | 'hip3_open_interest' | 'hip3_funding';
+type WsChannel = 'orderbook' | 'trades' | 'candles' | 'liquidations' | 'ticker' | 'all_tickers' | 'open_interest' | 'funding' | 'lighter_orderbook' | 'lighter_trades' | 'lighter_candles' | 'lighter_open_interest' | 'lighter_funding' | 'lighter_l3_orderbook' | 'hip3_orderbook' | 'hip3_trades' | 'hip3_candles' | 'hip3_open_interest' | 'hip3_funding' | 'hip3_liquidations' | 'l4_diffs' | 'l4_orders' | 'hip3_l4_diffs' | 'hip3_l4_orders';
 /** Subscribe message from client */
 interface WsSubscribe {
     op: 'subscribe';
@@ -703,8 +704,24 @@ interface WsGapDetected {
     /** Gap duration in minutes */
     duration_minutes: number;
 }
+/** L4 snapshot (sent on l4_diffs/hip3_l4_diffs subscription) */
+interface WsL4Snapshot {
+    type: 'l4_snapshot';
+    channel: WsChannel;
+    coin: string;
+    last_block_number: number;
+    timestamp: number;
+    data: any;
+}
+/** L4 batched data (all L4 channels) */
+interface WsL4Batch {
+    type: 'l4_batch';
+    channel: WsChannel;
+    coin: string;
+    data: any[];
+}
 /** Server message union type */
-type WsServerMessage = WsSubscribed | WsUnsubscribed | WsPong | WsError | WsData | WsReplayStarted | WsReplayPaused | WsReplayResumed | WsReplayCompleted | WsReplayStopped | WsReplaySnapshot | WsHistoricalData | WsHistoricalTickData | WsStreamStarted | WsStreamProgress | WsHistoricalBatch | WsStreamCompleted | WsStreamStopped | WsGapDetected;
+type WsServerMessage = WsSubscribed | WsUnsubscribed | WsPong | WsError | WsData | WsReplayStarted | WsReplayPaused | WsReplayResumed | WsReplayCompleted | WsReplayStopped | WsReplaySnapshot | WsHistoricalData | WsHistoricalTickData | WsStreamStarted | WsStreamProgress | WsHistoricalBatch | WsStreamCompleted | WsStreamStopped | WsGapDetected | WsL4Snapshot | WsL4Batch;
 /**
  * WebSocket connection options.
  *
@@ -1332,17 +1349,17 @@ declare class OrderBookResource {
     private coinTransform;
     constructor(http: HttpClient, basePath?: string, coinTransform?: (coin: string) => string);
     /**
-     * Get order book snapshot for a coin
+     * Get order book snapshot for a symbol
      *
-     * @param coin - The coin symbol (e.g., 'BTC', 'ETH')
+     * @param symbol - The symbol (e.g., 'BTC', 'ETH')
      * @param params - Optional parameters
      * @returns Order book snapshot
      */
-    get(coin: string, params?: GetOrderBookParams): Promise<OrderBook>;
+    get(symbol: string, params?: GetOrderBookParams): Promise<OrderBook>;
     /**
      * Get historical order book snapshots with cursor-based pagination
      *
-     * @param coin - The coin symbol (e.g., 'BTC', 'ETH')
+     * @param symbol - The symbol (e.g., 'BTC', 'ETH')
      * @param params - Time range and cursor pagination parameters (start and end are required)
      * @returns CursorResponse with order book snapshots and nextCursor for pagination
      *
@@ -1366,7 +1383,7 @@ declare class OrderBookResource {
      * }
      * ```
      */
-    history(coin: string, params: OrderBookHistoryParams): Promise<CursorResponse<OrderBook[]>>;
+    history(symbol: string, params: OrderBookHistoryParams): Promise<CursorResponse<OrderBook[]>>;
     /**
      * Get raw tick-level orderbook data (Enterprise tier only).
      *
@@ -1376,7 +1393,7 @@ declare class OrderBookResource {
      *
      * For automatic reconstruction, use `historyReconstructed()` instead.
      *
-     * @param coin - The coin symbol (e.g., 'BTC', 'ETH')
+     * @param symbol - The symbol (e.g., 'BTC', 'ETH')
      * @param params - Time range parameters
      * @returns Tick data with checkpoint and deltas
      *
@@ -1396,7 +1413,7 @@ declare class OrderBookResource {
      * }
      * ```
      */
-    historyTick(coin: string, params: TickHistoryParams): Promise<TickData>;
+    historyTick(symbol: string, params: TickHistoryParams): Promise<TickData>;
     /**
      * Get reconstructed tick-level orderbook history (Enterprise tier only).
      *
@@ -1406,7 +1423,7 @@ declare class OrderBookResource {
      * For large time ranges, consider using `historyTick()` with the
      * `OrderBookReconstructor.iterate()` method for memory efficiency.
      *
-     * @param coin - The coin symbol (e.g., 'BTC', 'ETH')
+     * @param symbol - The symbol (e.g., 'BTC', 'ETH')
      * @param params - Time range parameters
      * @param options - Reconstruction options
      * @returns Array of reconstructed orderbook snapshots
@@ -1430,7 +1447,7 @@ declare class OrderBookResource {
      * );
      * ```
      */
-    historyReconstructed(coin: string, params: TickHistoryParams, options?: ReconstructOptions): Promise<ReconstructedOrderBook[]>;
+    historyReconstructed(symbol: string, params: TickHistoryParams, options?: ReconstructOptions): Promise<ReconstructedOrderBook[]>;
     /**
      * Create a reconstructor for streaming tick-level data.
      *
@@ -1465,7 +1482,7 @@ declare class OrderBookResource {
      * per API request and yielding reconstructed orderbook snapshots one at a time.
      * Memory-efficient for processing large time ranges.
      *
-     * @param coin - The coin symbol (e.g., 'BTC', 'ETH')
+     * @param symbol - The symbol (e.g., 'BTC', 'ETH')
      * @param params - Time range parameters
      * @param depth - Maximum price levels to include in output snapshots
      * @yields Reconstructed orderbook snapshots
@@ -1488,7 +1505,7 @@ declare class OrderBookResource {
      * }
      * ```
      */
-    iterateTickHistory(coin: string, params: TickHistoryParams, depth?: number): AsyncGenerator<ReconstructedOrderBook, void, undefined>;
+    iterateTickHistory(symbol: string, params: TickHistoryParams, depth?: number): AsyncGenerator<ReconstructedOrderBook, void, undefined>;
 }
 
 /**
@@ -1525,12 +1542,12 @@ declare class TradesResource {
     private coinTransform;
     constructor(http: HttpClient, basePath?: string, coinTransform?: (coin: string) => string);
     /**
-     * Get trade history for a coin using cursor-based pagination
+     * Get trade history for a symbol using cursor-based pagination
      *
      * Uses cursor-based pagination by default, which is more efficient for large datasets.
      * Use the `nextCursor` from the response as the `cursor` parameter to get the next page.
      *
-     * @param coin - The coin symbol (e.g., 'BTC', 'ETH')
+     * @param symbol - The symbol (e.g., 'BTC', 'ETH')
      * @param params - Time range and cursor pagination parameters (start and end are required)
      * @returns Object with trades array and nextCursor for pagination
      *
@@ -1554,20 +1571,20 @@ declare class TradesResource {
      * }
      * ```
      */
-    list(coin: string, params: GetTradesCursorParams): Promise<CursorResponse<Trade[]>>;
+    list(symbol: string, params: GetTradesCursorParams): Promise<CursorResponse<Trade[]>>;
     /**
-     * Get most recent trades for a coin.
+     * Get most recent trades for a symbol.
      *
      * Note: This method is available for Lighter (client.lighter.trades.recent())
      * and HIP-3 (client.hyperliquid.hip3.trades.recent()) which have real-time data
      * ingestion. Hyperliquid uses hourly backfill so this endpoint is not available
      * for Hyperliquid.
      *
-     * @param coin - The coin symbol (e.g., 'BTC', 'ETH')
+     * @param symbol - The symbol (e.g., 'BTC', 'ETH')
      * @param limit - Number of trades to return (default: 100)
      * @returns Array of recent trades
      */
-    recent(coin: string, limit?: number): Promise<Trade[]>;
+    recent(symbol: string, limit?: number): Promise<Trade[]>;
 }
 
 /**
@@ -1704,20 +1721,20 @@ declare class FundingResource {
     private coinTransform;
     constructor(http: HttpClient, basePath?: string, coinTransform?: (coin: string) => string);
     /**
-     * Get funding rate history for a coin with cursor-based pagination
+     * Get funding rate history for a symbol with cursor-based pagination
      *
-     * @param coin - The coin symbol (e.g., 'BTC', 'ETH')
+     * @param symbol - The symbol (e.g., 'BTC', 'ETH')
      * @param params - Time range and cursor pagination parameters (start and end are required)
      * @returns CursorResponse with funding rate records and nextCursor for pagination
      */
-    history(coin: string, params: FundingHistoryParams): Promise<CursorResponse<FundingRate[]>>;
+    history(symbol: string, params: FundingHistoryParams): Promise<CursorResponse<FundingRate[]>>;
     /**
-     * Get current funding rate for a coin
+     * Get current funding rate for a symbol
      *
-     * @param coin - The coin symbol (e.g., 'BTC', 'ETH')
+     * @param symbol - The symbol (e.g., 'BTC', 'ETH')
      * @returns Current funding rate
      */
-    current(coin: string): Promise<FundingRate>;
+    current(symbol: string): Promise<FundingRate>;
 }
 
 /**
@@ -1754,20 +1771,20 @@ declare class OpenInterestResource {
     private coinTransform;
     constructor(http: HttpClient, basePath?: string, coinTransform?: (coin: string) => string);
     /**
-     * Get open interest history for a coin with cursor-based pagination
+     * Get open interest history for a symbol with cursor-based pagination
      *
-     * @param coin - The coin symbol (e.g., 'BTC', 'ETH')
+     * @param symbol - The symbol (e.g., 'BTC', 'ETH')
      * @param params - Time range and cursor pagination parameters (start and end are required)
      * @returns CursorResponse with open interest records and nextCursor for pagination
      */
-    history(coin: string, params: OpenInterestHistoryParams): Promise<CursorResponse<OpenInterest[]>>;
+    history(symbol: string, params: OpenInterestHistoryParams): Promise<CursorResponse<OpenInterest[]>>;
     /**
-     * Get current open interest for a coin
+     * Get current open interest for a symbol
      *
-     * @param coin - The coin symbol (e.g., 'BTC', 'ETH')
+     * @param symbol - The symbol (e.g., 'BTC', 'ETH')
      * @returns Current open interest
      */
-    current(coin: string): Promise<OpenInterest>;
+    current(symbol: string): Promise<OpenInterest>;
 }
 
 /**
@@ -1810,11 +1827,11 @@ declare class CandlesResource {
     /**
      * Get historical OHLCV candle data with cursor-based pagination
      *
-     * @param coin - The coin symbol (e.g., 'BTC', 'ETH')
+     * @param symbol - The symbol (e.g., 'BTC', 'ETH')
      * @param params - Time range, interval, and cursor pagination parameters (start and end are required)
      * @returns CursorResponse with candle records and nextCursor for pagination
      */
-    history(coin: string, params: CandleHistoryParams): Promise<CursorResponse<Candle[]>>;
+    history(symbol: string, params: CandleHistoryParams): Promise<CursorResponse<Candle[]>>;
 }
 
 /**
@@ -1855,15 +1872,16 @@ declare class CandlesResource {
 declare class LiquidationsResource {
     private http;
     private basePath;
-    constructor(http: HttpClient, basePath?: string);
+    private coinTransform;
+    constructor(http: HttpClient, basePath?: string, coinTransform?: (coin: string) => string);
     /**
-     * Get liquidation history for a coin with cursor-based pagination
+     * Get liquidation history for a symbol with cursor-based pagination
      *
-     * @param coin - The coin symbol (e.g., 'BTC', 'ETH')
+     * @param symbol - The symbol (e.g., 'BTC', 'ETH')
      * @param params - Time range and cursor pagination parameters (start and end are required)
      * @returns CursorResponse with liquidation records and nextCursor for pagination
      */
-    history(coin: string, params: LiquidationHistoryParams): Promise<CursorResponse<Liquidation[]>>;
+    history(symbol: string, params: LiquidationHistoryParams): Promise<CursorResponse<Liquidation[]>>;
     /**
      * Get liquidation history for a specific user
      *
@@ -1882,11 +1900,11 @@ declare class LiquidationsResource {
      * Returns pre-aggregated data with total/long/short USD volumes per bucket,
      * reducing data transfer by 100-1000x compared to individual liquidation records.
      *
-     * @param coin - The coin symbol (e.g., 'BTC', 'ETH')
+     * @param symbol - The symbol (e.g., 'BTC', 'ETH')
      * @param params - Time range, cursor, and interval parameters
      * @returns CursorResponse with liquidation volume buckets
      */
-    volume(coin: string, params: LiquidationVolumeParams): Promise<CursorResponse<LiquidationVolume[]>>;
+    volume(symbol: string, params: LiquidationVolumeParams): Promise<CursorResponse<LiquidationVolume[]>>;
 }
 
 /**
@@ -2138,6 +2156,226 @@ declare class Web3Resource {
     subscribe(tier: 'build' | 'pro', paymentSignature: string): Promise<Web3SubscribeResult>;
 }
 
+interface OrderHistoryParams extends CursorPaginationParams {
+    user?: string;
+    status?: string;
+    order_type?: string;
+}
+interface OrderFlowParams {
+    start: number | string;
+    end: number | string;
+    interval?: string;
+    limit?: number;
+}
+interface TpslParams extends CursorPaginationParams {
+    user?: string;
+    triggered?: boolean;
+}
+/**
+ * Orders API resource
+ *
+ * @example
+ * ```typescript
+ * // Get order history
+ * const result = await client.hyperliquid.orders.history('BTC', {
+ *   start: Date.now() - 86400000,
+ *   end: Date.now(),
+ *   limit: 1000
+ * });
+ *
+ * // Get order flow
+ * const flow = await client.hyperliquid.orders.flow('BTC', {
+ *   start: Date.now() - 86400000,
+ *   end: Date.now(),
+ *   interval: '1h'
+ * });
+ *
+ * // Get TP/SL orders
+ * const tpsl = await client.hyperliquid.orders.tpsl('BTC', {
+ *   start: Date.now() - 86400000,
+ *   end: Date.now()
+ * });
+ * ```
+ */
+declare class OrdersResource {
+    private http;
+    private basePath;
+    private coinTransform;
+    constructor(http: HttpClient, basePath?: string, coinTransform?: (s: string) => string);
+    /**
+     * Get order history for a symbol with cursor-based pagination
+     *
+     * @param symbol - The symbol (e.g., 'BTC', 'ETH')
+     * @param params - Time range, cursor pagination, and filter parameters
+     * @returns CursorResponse with order records and nextCursor for pagination
+     */
+    history(symbol: string, params: OrderHistoryParams): Promise<CursorResponse<any[]>>;
+    /**
+     * Get order flow for a symbol
+     *
+     * @param symbol - The symbol (e.g., 'BTC', 'ETH')
+     * @param params - Time range and interval parameters
+     * @returns CursorResponse with order flow records
+     */
+    flow(symbol: string, params: OrderFlowParams): Promise<CursorResponse<any[]>>;
+    /**
+     * Get TP/SL orders for a symbol with cursor-based pagination
+     *
+     * @param symbol - The symbol (e.g., 'BTC', 'ETH')
+     * @param params - Time range, cursor pagination, and filter parameters
+     * @returns CursorResponse with TP/SL order records
+     */
+    tpsl(symbol: string, params: TpslParams): Promise<CursorResponse<any[]>>;
+}
+
+interface L4OrderBookParams {
+    timestamp?: number | string;
+    depth?: number;
+}
+/**
+ * L4 Order Book API resource
+ *
+ * Access L4 orderbook snapshots, diffs, and history.
+ *
+ * @example
+ * ```typescript
+ * // Get current L4 orderbook
+ * const orderbook = await client.hyperliquid.l4Orderbook.get('BTC');
+ *
+ * // Get L4 orderbook diffs
+ * const diffs = await client.hyperliquid.l4Orderbook.diffs('BTC', {
+ *   start: Date.now() - 86400000,
+ *   end: Date.now(),
+ *   limit: 1000
+ * });
+ *
+ * // Get L4 orderbook history
+ * const history = await client.hyperliquid.l4Orderbook.history('BTC', {
+ *   start: Date.now() - 86400000,
+ *   end: Date.now(),
+ *   limit: 1000
+ * });
+ * ```
+ */
+declare class L4OrderBookResource {
+    private http;
+    private basePath;
+    private coinTransform;
+    constructor(http: HttpClient, basePath?: string, coinTransform?: (s: string) => string);
+    /**
+     * Get L4 order book snapshot for a symbol
+     *
+     * @param symbol - The symbol (e.g., 'BTC', 'ETH')
+     * @param params - Optional parameters (timestamp, depth)
+     * @returns L4 order book snapshot
+     */
+    get(symbol: string, params?: L4OrderBookParams): Promise<any>;
+    /**
+     * Get L4 order book diffs with cursor-based pagination
+     *
+     * @param symbol - The symbol (e.g., 'BTC', 'ETH')
+     * @param params - Time range and cursor pagination parameters
+     * @returns CursorResponse with L4 orderbook diffs and nextCursor for pagination
+     */
+    diffs(symbol: string, params: CursorPaginationParams): Promise<CursorResponse<any[]>>;
+    /**
+     * Get L4 order book history with cursor-based pagination
+     *
+     * @param symbol - The symbol (e.g., 'BTC', 'ETH')
+     * @param params - Time range and cursor pagination parameters
+     * @returns CursorResponse with L4 orderbook snapshots and nextCursor for pagination
+     */
+    history(symbol: string, params: CursorPaginationParams): Promise<CursorResponse<any[]>>;
+}
+
+interface L2OrderBookParams {
+    timestamp?: number | string;
+    depth?: number;
+}
+/**
+ * L2 Full-Depth Order Book API resource (derived from L4 data)
+ *
+ * Access aggregated price-level orderbook snapshots, history, and tick-level diffs.
+ * Data available from March 10, 2026.
+ *
+ * @example
+ * ```typescript
+ * // Get current full-depth L2 orderbook
+ * const orderbook = await client.hyperliquid.l2Orderbook.get('BTC');
+ *
+ * // Get L2 orderbook at a historical timestamp
+ * const historical = await client.hyperliquid.l2Orderbook.get('BTC', {
+ *   timestamp: 1711900800000
+ * });
+ *
+ * // Get L2 orderbook history
+ * const history = await client.hyperliquid.l2Orderbook.history('BTC', {
+ *   start: Date.now() - 86400000,
+ *   end: Date.now(),
+ *   limit: 100
+ * });
+ * ```
+ */
+declare class L2OrderBookResource {
+    private http;
+    private basePath;
+    private coinTransform;
+    constructor(http: HttpClient, basePath?: string, coinTransform?: (s: string) => string);
+    /** Get full-depth L2 order book snapshot. */
+    get(symbol: string, params?: L2OrderBookParams): Promise<any>;
+    /** Get paginated L2 full-depth history. */
+    history(symbol: string, params: CursorPaginationParams & {
+        depth?: number;
+    }): Promise<CursorResponse<any[]>>;
+    /** Get tick-level L2 order book diffs. */
+    diffs(symbol: string, params: CursorPaginationParams): Promise<CursorResponse<any[]>>;
+}
+
+interface L3OrderBookParams {
+    timestamp?: number | string;
+    depth?: number;
+}
+/**
+ * L3 Order Book API resource (Lighter only)
+ *
+ * Access L3 orderbook snapshots and history from Lighter.xyz.
+ *
+ * @example
+ * ```typescript
+ * // Get current L3 orderbook
+ * const orderbook = await client.lighter.l3Orderbook.get('BTC');
+ *
+ * // Get L3 orderbook history
+ * const history = await client.lighter.l3Orderbook.history('BTC', {
+ *   start: Date.now() - 86400000,
+ *   end: Date.now(),
+ *   limit: 1000
+ * });
+ * ```
+ */
+declare class L3OrderBookResource {
+    private http;
+    private basePath;
+    private coinTransform;
+    constructor(http: HttpClient, basePath?: string, coinTransform?: (s: string) => string);
+    /**
+     * Get L3 order book snapshot for a symbol
+     *
+     * @param symbol - The symbol (e.g., 'BTC', 'ETH')
+     * @param params - Optional parameters (timestamp, depth)
+     * @returns L3 order book snapshot
+     */
+    get(symbol: string, params?: L3OrderBookParams): Promise<any>;
+    /**
+     * Get L3 order book history with cursor-based pagination
+     *
+     * @param symbol - The symbol (e.g., 'BTC', 'ETH')
+     * @param params - Time range and cursor pagination parameters
+     * @returns CursorResponse with L3 orderbook snapshots and nextCursor for pagination
+     */
+    history(symbol: string, params: CursorPaginationParams): Promise<CursorResponse<any[]>>;
+}
+
 /**
  * Hyperliquid exchange client
  *
@@ -2179,6 +2417,18 @@ declare class HyperliquidClient {
      * Liquidation events (May 2025+)
      */
     readonly liquidations: LiquidationsResource;
+    /**
+     * Order history, flow, and TP/SL
+     */
+    readonly orders: OrdersResource;
+    /**
+     * L4 order book (snapshots, diffs, history)
+     */
+    readonly l4Orderbook: L4OrderBookResource;
+    /**
+     * L2 full-depth order book (derived from L4)
+     */
+    readonly l2Orderbook: L2OrderBookResource;
     /**
      * HIP-3 builder-deployed perpetuals (February 2026+)
      */
@@ -2186,27 +2436,27 @@ declare class HyperliquidClient {
     private http;
     constructor(http: HttpClient);
     /**
-     * Get per-coin data freshness across all data types
+     * Get per-symbol data freshness across all data types
      *
-     * @param coin - The coin symbol (e.g., 'BTC', 'ETH')
-     * @returns Per-coin freshness with last_updated and lag_ms for each data type
+     * @param symbol - The symbol (e.g., 'BTC', 'ETH')
+     * @returns Per-symbol freshness with last_updated and lag_ms for each data type
      */
-    freshness(coin: string): Promise<CoinFreshness>;
+    freshness(symbol: string): Promise<CoinFreshness>;
     /**
      * Get combined market summary (price, funding, OI, volume, liquidations) in one call
      *
-     * @param coin - The coin symbol (e.g., 'BTC', 'ETH')
+     * @param symbol - The symbol (e.g., 'BTC', 'ETH')
      * @returns Combined market summary
      */
-    summary(coin: string): Promise<CoinSummary>;
+    summary(symbol: string): Promise<CoinSummary>;
     /**
      * Get mark/oracle/mid price history (projected from OI data)
      *
-     * @param coin - The coin symbol (e.g., 'BTC', 'ETH')
+     * @param symbol - The symbol (e.g., 'BTC', 'ETH')
      * @param params - Time range, cursor, and interval parameters
      * @returns CursorResponse with price snapshots
      */
-    priceHistory(coin: string, params: PriceHistoryParams): Promise<CursorResponse<PriceSnapshot[]>>;
+    priceHistory(symbol: string, params: PriceHistoryParams): Promise<CursorResponse<PriceSnapshot[]>>;
 }
 /**
  * HIP-3 builder-deployed perpetuals client
@@ -2246,30 +2496,46 @@ declare class Hip3Client {
      * OHLCV candle data
      */
     readonly candles: CandlesResource;
+    /**
+     * Liquidation events
+     */
+    readonly liquidations: LiquidationsResource;
+    /**
+     * Order history, flow, and TP/SL
+     */
+    readonly orders: OrdersResource;
+    /**
+     * L4 order book (snapshots, diffs, history)
+     */
+    readonly l4Orderbook: L4OrderBookResource;
+    /**
+     * L2 full-depth order book (derived from L4)
+     */
+    readonly l2Orderbook: L2OrderBookResource;
     private http;
     constructor(http: HttpClient);
     /**
-     * Get per-coin data freshness across all data types
+     * Get per-symbol data freshness across all data types
      *
-     * @param coin - The coin symbol (case-sensitive, e.g., 'km:US500')
-     * @returns Per-coin freshness with last_updated and lag_ms for each data type
+     * @param symbol - The symbol (case-sensitive, e.g., 'km:US500')
+     * @returns Per-symbol freshness with last_updated and lag_ms for each data type
      */
-    freshness(coin: string): Promise<CoinFreshness>;
+    freshness(symbol: string): Promise<CoinFreshness>;
     /**
      * Get combined market summary (price, funding, OI) in one call
      *
-     * @param coin - The coin symbol (case-sensitive, e.g., 'km:US500')
+     * @param symbol - The symbol (case-sensitive, e.g., 'km:US500')
      * @returns Combined market summary
      */
-    summary(coin: string): Promise<CoinSummary>;
+    summary(symbol: string): Promise<CoinSummary>;
     /**
      * Get mark/oracle/mid price history (projected from OI data)
      *
-     * @param coin - The coin symbol (case-sensitive, e.g., 'km:US500')
+     * @param symbol - The symbol (case-sensitive, e.g., 'km:US500')
      * @param params - Time range, cursor, and interval parameters
      * @returns CursorResponse with price snapshots
      */
-    priceHistory(coin: string, params: PriceHistoryParams): Promise<CursorResponse<PriceSnapshot[]>>;
+    priceHistory(symbol: string, params: PriceHistoryParams): Promise<CursorResponse<PriceSnapshot[]>>;
 }
 /**
  * Lighter.xyz exchange client
@@ -2310,30 +2576,34 @@ declare class LighterClient {
      * OHLCV candle data
      */
     readonly candles: CandlesResource;
+    /**
+     * L3 order book (Lighter only)
+     */
+    readonly l3Orderbook: L3OrderBookResource;
     private http;
     constructor(http: HttpClient);
     /**
-     * Get per-coin data freshness across all data types
+     * Get per-symbol data freshness across all data types
      *
-     * @param coin - The coin symbol (e.g., 'BTC', 'ETH')
-     * @returns Per-coin freshness with last_updated and lag_ms for each data type
+     * @param symbol - The symbol (e.g., 'BTC', 'ETH')
+     * @returns Per-symbol freshness with last_updated and lag_ms for each data type
      */
-    freshness(coin: string): Promise<CoinFreshness>;
+    freshness(symbol: string): Promise<CoinFreshness>;
     /**
      * Get combined market summary (price, funding, OI) in one call
      *
-     * @param coin - The coin symbol (e.g., 'BTC', 'ETH')
+     * @param symbol - The symbol (e.g., 'BTC', 'ETH')
      * @returns Combined market summary
      */
-    summary(coin: string): Promise<CoinSummary>;
+    summary(symbol: string): Promise<CoinSummary>;
     /**
      * Get mark/oracle price history (projected from OI data)
      *
-     * @param coin - The coin symbol (e.g., 'BTC', 'ETH')
+     * @param symbol - The symbol (e.g., 'BTC', 'ETH')
      * @param params - Time range, cursor, and interval parameters
      * @returns CursorResponse with price snapshots
      */
-    priceHistory(coin: string, params: PriceHistoryParams): Promise<CursorResponse<PriceSnapshot[]>>;
+    priceHistory(symbol: string, params: PriceHistoryParams): Promise<CursorResponse<PriceSnapshot[]>>;
 }
 
 /**
@@ -2784,6 +3054,109 @@ declare class OxArchiveWs {
     private handleMessage;
 }
 
+/**
+ * L4 order book reconstructor with matching engine.
+ *
+ * Reconstructs Hyperliquid and HIP-3 L4 order books from checkpoints and diffs.
+ * The same class works for both exchanges — the diff format is identical.
+ *
+ * When a new order crosses the spread, the matching engine filled opposite-side
+ * orders at crossing prices. Without removing them, the reconstructed book will
+ * be "crossed" (best bid > best ask).
+ *
+ * Ref: https://github.com/hyperliquid-dex/order_book_server
+ */
+interface L4Order {
+    oid: number;
+    userAddress: string;
+    side: 'B' | 'A';
+    price: number;
+    size: number;
+}
+interface L2Level {
+    px: number;
+    sz: number;
+    n: number;
+}
+interface L4Diff {
+    diff_type?: 'new' | 'update' | 'remove';
+    diffType?: 'new' | 'update' | 'remove';
+    oid: number;
+    side: 'B' | 'A';
+    price: number;
+    new_size?: number | null;
+    newSize?: number | null;
+    user_address?: string;
+    userAddress?: string;
+    block_number?: number;
+    blockNumber?: number;
+}
+interface L4Checkpoint {
+    bids: Array<{
+        oid: number;
+        user_address?: string;
+        userAddress?: string;
+        side: string;
+        price: number;
+        size: number;
+    }>;
+    asks: Array<{
+        oid: number;
+        user_address?: string;
+        userAddress?: string;
+        side: string;
+        price: number;
+        size: number;
+    }>;
+}
+/**
+ * L4 orderbook reconstructor with matching engine.
+ *
+ * Works identically for Hyperliquid and HIP-3 — same diff format,
+ * same checkpoint format, same crossing logic.
+ *
+ * @example
+ * ```typescript
+ * const book = new L4OrderBookReconstructor();
+ * book.loadCheckpoint(checkpoint);
+ *
+ * // Group diffs by block, apply in order
+ * for (const bn of sortedBlockNumbers) {
+ *   const nr = nonRestingByBlock.get(bn);
+ *   for (const diff of blocks.get(bn)!) {
+ *     book.applyDiff(diff, nr);
+ *   }
+ * }
+ *
+ * console.log(book.isCrossed()); // false
+ * const { bids: l2Bids, asks: l2Asks } = book.deriveL2();
+ * ```
+ */
+declare class L4OrderBookReconstructor {
+    private orders;
+    private bidPrices;
+    private askPrices;
+    /** Initialize from an L4 checkpoint. */
+    loadCheckpoint(checkpoint: L4Checkpoint): void;
+    /** Apply a single L4 diff with matching engine. */
+    applyDiff(diff: L4Diff, nonRestingOids?: Set<number>): void;
+    /** Return bids sorted by price descending. */
+    bids(): L4Order[];
+    /** Return asks sorted by price ascending. */
+    asks(): L4Order[];
+    bestBid(): number | null;
+    bestAsk(): number | null;
+    /** Check if the book is crossed. Should be false after correct reconstruction. */
+    isCrossed(): boolean;
+    get bidCount(): number;
+    get askCount(): number;
+    /** Aggregate L4 orders into L2 price levels. */
+    deriveL2(): {
+        bids: L2Level[];
+        asks: L2Level[];
+    };
+}
+
 /**
  * Zod schemas for runtime validation of API responses
  *
@@ -5243,4 +5616,4 @@ type ValidatedCandle = z.infer<typeof CandleSchema>;
 type ValidatedLiquidation = z.infer<typeof LiquidationSchema>;
 type ValidatedWsServerMessage = z.infer<typeof WsServerMessageSchema>;
 
-export { type ApiError, type ApiMeta, ApiMetaSchema, type ApiResponse, ApiResponseSchema, type Candle, CandleArrayResponseSchema, type CandleHistoryParams, type CandleInterval, CandleIntervalSchema, CandleSchema, type ClientOptions, type CoinFreshness, CoinFreshnessResponseSchema, CoinFreshnessSchema, type CoinSummary, CoinSummaryResponseSchema, CoinSummarySchema, type CompletenessMetrics, type CoverageGap, type CoverageResponse, type CursorResponse, type DataCadence, type DataFreshness, type DataTypeCoverage, type DataTypeFreshnessInfo, DataTypeFreshnessInfoSchema, type DataTypeStatus, type ExchangeCoverage, type ExchangeLatency, type ExchangeStatus, type FundingHistoryParams, type FundingRate, FundingRateArrayResponseSchema, FundingRateResponseSchema, FundingRateSchema, type GetOrderBookParams, type GetTradesCursorParams, Hip3Client, type Hip3Instrument, HyperliquidClient, type Incident, type IncidentSeverityValue, type IncidentStatusValue, type IncidentsResponse, type Instrument, InstrumentArrayResponseSchema, InstrumentResponseSchema, InstrumentSchema, type InstrumentType, InstrumentTypeSchema, type LatencyResponse, LighterClient, type LighterGranularity, type LighterInstrument, type Liquidation, LiquidationArrayResponseSchema, type LiquidationHistoryParams, LiquidationSchema, LiquidationSideSchema, type LiquidationVolume, LiquidationVolumeArrayResponseSchema, type LiquidationVolumeParams, LiquidationVolumeSchema, type LiquidationsByUserParams, type ListIncidentsParams, type OiFundingInterval, type OpenInterest, OpenInterestArrayResponseSchema, type OpenInterestHistoryParams, OpenInterestResponseSchema, OpenInterestSchema, type OrderBook, OrderBookArrayResponseSchema, type OrderBookHistoryParams, OrderBookReconstructor, OrderBookResponseSchema, OrderBookSchema, type OrderbookDelta, OxArchive, OxArchiveError, OxArchiveWs, type Pagination, type PriceHistoryParams, type PriceLevel, PriceLevelSchema, type PriceSnapshot, PriceSnapshotArrayResponseSchema, PriceSnapshotSchema, type ReconstructOptions, type ReconstructedOrderBook, type RestApiLatency, type SiweChallenge, type SlaActual, type SlaParams, type SlaResponse, type SlaTargets, type StatusResponse, type SymbolCoverageOptions, type SymbolCoverageResponse, type SymbolDataTypeCoverage, type SystemStatusValue, type TickData, type TickHistoryParams, type Timestamp, type TimestampedRecord, TimestampedRecordSchema, type Trade, TradeArrayResponseSchema, type TradeDirection, TradeDirectionSchema, TradeSchema, type TradeSide, TradeSideSchema, type ValidatedApiMeta, type ValidatedCandle, type ValidatedFundingRate, type ValidatedInstrument, type ValidatedLiquidation, type ValidatedOpenInterest, type ValidatedOrderBook, type ValidatedPriceLevel, type ValidatedTrade, type ValidatedWsServerMessage, type Web3ApiKey, type Web3KeysList, type Web3PaymentRequired, type Web3RevokeResult, type Web3SignupResult, type Web3SubscribeResult, type WebSocketLatency, type WsChannel, WsChannelSchema, type WsClientMessage, type WsConnectionState, WsConnectionStateSchema, type WsData, WsDataSchema, type WsError, WsErrorSchema, type WsEventHandlers, type WsGapDetected, type WsHistoricalBatch, WsHistoricalBatchSchema, type WsHistoricalData, WsHistoricalDataSchema, type WsHistoricalTickData, type WsOptions, type WsPing, type WsPong, WsPongSchema, type WsReplay, type WsReplayCompleted, WsReplayCompletedSchema, type WsReplayPause, type WsReplayPaused, WsReplayPausedSchema, type WsReplayResume, type WsReplayResumed, WsReplayResumedSchema, type WsReplaySeek, type WsReplaySnapshot, WsReplaySnapshotSchema, type WsReplayStarted, WsReplayStartedSchema, type WsReplayStop, type WsReplayStopped, WsReplayStoppedSchema, type WsServerMessage, WsServerMessageSchema, type WsStream, type WsStreamCompleted, WsStreamCompletedSchema, type WsStreamProgress, WsStreamProgressSchema, type WsStreamStarted, WsStreamStartedSchema, type WsStreamStop, type WsStreamStopped, WsStreamStoppedSchema, type WsSubscribe, type WsSubscribed, WsSubscribedSchema, type WsUnsubscribe, type WsUnsubscribed, WsUnsubscribedSchema, OxArchive as default, reconstructFinal, reconstructOrderBook };
+export { type ApiError, type ApiMeta, ApiMetaSchema, type ApiResponse, ApiResponseSchema, type Candle, CandleArrayResponseSchema, type CandleHistoryParams, type CandleInterval, CandleIntervalSchema, CandleSchema, type ClientOptions, type CoinFreshness, CoinFreshnessResponseSchema, CoinFreshnessSchema, type CoinSummary, CoinSummaryResponseSchema, CoinSummarySchema, type CompletenessMetrics, type CoverageGap, type CoverageResponse, type CursorResponse, type DataCadence, type DataFreshness, type DataTypeCoverage, type DataTypeFreshnessInfo, DataTypeFreshnessInfoSchema, type DataTypeStatus, type ExchangeCoverage, type ExchangeLatency, type ExchangeStatus, type FundingHistoryParams, type FundingRate, FundingRateArrayResponseSchema, FundingRateResponseSchema, FundingRateSchema, type GetOrderBookParams, type GetTradesCursorParams, Hip3Client, type Hip3Instrument, HyperliquidClient, type Incident, type IncidentSeverityValue, type IncidentStatusValue, type IncidentsResponse, type Instrument, InstrumentArrayResponseSchema, InstrumentResponseSchema, InstrumentSchema, type InstrumentType, InstrumentTypeSchema, type L2Level, type L2OrderBookParams, L2OrderBookResource, type L4Checkpoint, type L4Diff, type L4Order, L4OrderBookReconstructor, type LatencyResponse, LighterClient, type LighterGranularity, type LighterInstrument, type Liquidation, LiquidationArrayResponseSchema, type LiquidationHistoryParams, LiquidationSchema, LiquidationSideSchema, type LiquidationVolume, LiquidationVolumeArrayResponseSchema, type LiquidationVolumeParams, LiquidationVolumeSchema, type LiquidationsByUserParams, type ListIncidentsParams, type OiFundingInterval, type OpenInterest, OpenInterestArrayResponseSchema, type OpenInterestHistoryParams, OpenInterestResponseSchema, OpenInterestSchema, type OrderBook, OrderBookArrayResponseSchema, type OrderBookHistoryParams, OrderBookReconstructor, OrderBookResponseSchema, OrderBookSchema, type OrderbookDelta, OxArchive, OxArchiveError, OxArchiveWs, type Pagination, type PriceHistoryParams, type PriceLevel, PriceLevelSchema, type PriceSnapshot, PriceSnapshotArrayResponseSchema, PriceSnapshotSchema, type ReconstructOptions, type ReconstructedOrderBook, type RestApiLatency, type SiweChallenge, type SlaActual, type SlaParams, type SlaResponse, type SlaTargets, type StatusResponse, type SymbolCoverageOptions, type SymbolCoverageResponse, type SymbolDataTypeCoverage, type SystemStatusValue, type TickData, type TickHistoryParams, type Timestamp, type TimestampedRecord, TimestampedRecordSchema, type Trade, TradeArrayResponseSchema, type TradeDirection, TradeDirectionSchema, TradeSchema, type TradeSide, TradeSideSchema, type ValidatedApiMeta, type ValidatedCandle, type ValidatedFundingRate, type ValidatedInstrument, type ValidatedLiquidation, type ValidatedOpenInterest, type ValidatedOrderBook, type ValidatedPriceLevel, type ValidatedTrade, type ValidatedWsServerMessage, type Web3ApiKey, type Web3KeysList, type Web3PaymentRequired, type Web3RevokeResult, type Web3SignupResult, type Web3SubscribeResult, type WebSocketLatency, type WsChannel, WsChannelSchema, type WsClientMessage, type WsConnectionState, WsConnectionStateSchema, type WsData, WsDataSchema, type WsError, WsErrorSchema, type WsEventHandlers, type WsGapDetected, type WsHistoricalBatch, WsHistoricalBatchSchema, type WsHistoricalData, WsHistoricalDataSchema, type WsHistoricalTickData, type WsL4Batch, type WsL4Snapshot, type WsOptions, type WsPing, type WsPong, WsPongSchema, type WsReplay, type WsReplayCompleted, WsReplayCompletedSchema, type WsReplayPause, type WsReplayPaused, WsReplayPausedSchema, type WsReplayResume, type WsReplayResumed, WsReplayResumedSchema, type WsReplaySeek, type WsReplaySnapshot, WsReplaySnapshotSchema, type WsReplayStarted, WsReplayStartedSchema, type WsReplayStop, type WsReplayStopped, WsReplayStoppedSchema, type WsServerMessage, WsServerMessageSchema, type WsStream, type WsStreamCompleted, WsStreamCompletedSchema, type WsStreamProgress, WsStreamProgressSchema, type WsStreamStarted, WsStreamStartedSchema, type WsStreamStop, type WsStreamStopped, WsStreamStoppedSchema, type WsSubscribe, type WsSubscribed, WsSubscribedSchema, type WsUnsubscribe, type WsUnsubscribed, WsUnsubscribedSchema, OxArchive as default, reconstructFinal, reconstructOrderBook };