@0xarchive/sdk 0.6.4 → 0.7.0

package/README.md

@@ -153,14 +153,24 @@ const tickData = await client.lighter.orderbook.historyTick('BTC', {
 console.log(`Checkpoint: ${tickData.checkpoint.bids.length} bids`);
 console.log(`Deltas: ${tickData.deltas.length} updates`);
 
-// Option 3: Memory-efficient iteration (for large datasets)
+// Option 3: Auto-paginating iterator (recommended for large time ranges)
+// Automatically handles pagination, fetching up to 1,000 deltas per request
+for await (const snapshot of client.lighter.orderbook.iterateTickHistory('BTC', {
+  start: Date.now() - 86400000, // 24 hours of data
+  end: Date.now()
+})) {
+  console.log(snapshot.timestamp, 'Mid:', snapshot.midPrice);
+  if (someCondition(snapshot)) break; // Early exit supported
+}
+
+// Option 4: Manual iteration (single page, for custom logic)
 const reconstructor = client.lighter.orderbook.createReconstructor();
 for (const snapshot of reconstructor.iterate(tickData.checkpoint, tickData.deltas)) {
   // Process each snapshot without loading all into memory
   if (someCondition(snapshot)) break; // Early exit if needed
 }
 
-// Option 4: Get only final state (most efficient)
+// Option 5: Get only final state (most efficient)
 const final = reconstructor.reconstructFinal(tickData.checkpoint, tickData.deltas);
 
 // Check for sequence gaps
@@ -173,10 +183,13 @@ if (gaps.length > 0) {
 **Methods:**
 | Method | Description |
 |--------|-------------|
-| `historyTick(coin, params)` | Get raw checkpoint + deltas for custom reconstruction |
-| `historyReconstructed(coin, params, options)` | Get fully reconstructed snapshots |
+| `historyTick(coin, params)` | Get raw checkpoint + deltas (single page, max 1,000 deltas) |
+| `historyReconstructed(coin, params, options)` | Get fully reconstructed snapshots (single page) |
+| `iterateTickHistory(coin, params, depth?)` | Auto-paginating async iterator for large time ranges |
 | `createReconstructor()` | Create a reconstructor instance for manual control |
 
+**Note:** The API returns a maximum of 1,000 deltas per request. For time ranges with more deltas, use `iterateTickHistory()` which handles pagination automatically.
+
 **ReconstructOptions:**
 | Option | Default | Description |
 |--------|---------|-------------|
@@ -211,6 +224,8 @@ while (result.nextCursor) {
 const recent = await client.lighter.trades.recent('BTC', 100);
 ```
 
+**Note:** The `recent()` method is only available for Lighter.xyz (`client.lighter.trades.recent()`). Hyperliquid does not have a recent trades endpoint - use `list()` with a time range instead.
+
 ### Instruments
 
 ```typescript
@@ -389,11 +404,25 @@ for (const exchange of coverage.exchanges) {
 const btc = await client.dataQuality.symbolCoverage('hyperliquid', 'BTC');
 const oi = btc.dataTypes.open_interest;
 console.log(`BTC OI completeness: ${oi.completeness}%`);
+console.log(`Historical coverage: ${oi.historicalCoverage}%`);  // Hour-level granularity
 console.log(`Gaps found: ${oi.gaps.length}`);
 for (const gap of oi.gaps.slice(0, 5)) {
   console.log(`  ${gap.durationMinutes} min gap: ${gap.start} -> ${gap.end}`);
 }
 
+// Check empirical data cadence (when available)
+const ob = btc.dataTypes.orderbook;
+if (ob.cadence) {
+  console.log(`Orderbook cadence: ~${ob.cadence.medianIntervalSeconds}s median, p95=${ob.cadence.p95IntervalSeconds}s`);
+}
+
+// Time-bounded gap detection (last 7 days)
+const weekAgo = Date.now() - 7 * 24 * 60 * 60 * 1000;
+const btc7d = await client.dataQuality.symbolCoverage('hyperliquid', 'BTC', {
+  from: weekAgo,
+  to: Date.now(),
+});
+
 // List incidents with filtering
 const result = await client.dataQuality.listIncidents({ status: 'open' });
 for (const incident of result.incidents) {
@@ -420,12 +449,21 @@ console.log(`API P99: ${sla.actual.apiLatencyP99Ms}ms (${sla.actual.latencyStatu
 | `status()` | Overall system health and per-exchange status |
 | `coverage()` | Data coverage summary for all exchanges |
 | `exchangeCoverage(exchange)` | Coverage details for a specific exchange |
-| `symbolCoverage(exchange, symbol)` | Coverage with gap detection for specific symbol |
+| `symbolCoverage(exchange, symbol, options?)` | Coverage with gap detection, cadence, and historical coverage |
 | `listIncidents(params)` | List incidents with filtering and pagination |
 | `getIncident(incidentId)` | Get specific incident details |
 | `latency()` | Current latency metrics (WebSocket, REST, data freshness) |
 | `sla(params)` | SLA compliance metrics for a specific month |
 
+**Note:** Data Quality endpoints (`coverage()`, `exchangeCoverage()`, `symbolCoverage()`) perform complex aggregation queries and may take 30-60 seconds on first request (results are cached server-side for 5 minutes). If you encounter timeout errors, create a client with a longer timeout:
+
+```typescript
+const client = new OxArchive({
+  apiKey: 'ox_your_api_key',
+  timeout: 60000  // 60 seconds for data quality endpoints
+});
+```
+
 ### Legacy API (Deprecated)
 
 The following legacy methods are deprecated and will be removed in v2.0. They default to Hyperliquid data:

package/dist/index.d.mts

@@ -671,6 +671,15 @@ interface CoverageGap {
     /** Duration of the gap in minutes */
     durationMinutes: number;
 }
+/** Empirical data cadence measurement based on last 7 days of data */
+interface DataCadence {
+    /** Median interval between consecutive records in seconds */
+    medianIntervalSeconds: number;
+    /** 95th percentile interval between consecutive records in seconds */
+    p95IntervalSeconds: number;
+    /** Number of intervals sampled for this measurement */
+    sampleCount: number;
+}
 /** Coverage for a specific symbol and data type */
 interface SymbolDataTypeCoverage {
     /** Earliest available data timestamp */
@@ -679,10 +688,21 @@ interface SymbolDataTypeCoverage {
     latest: string;
     /** Total number of records */
     totalRecords: number;
-    /** Completeness percentage (0-100) */
+    /** 24-hour completeness percentage (0-100) */
     completeness: number;
-    /** Detected data gaps */
+    /** Historical coverage percentage (0-100) based on hours with data / total hours */
+    historicalCoverage?: number;
+    /** Detected data gaps within the requested time window */
     gaps: CoverageGap[];
+    /** Empirical data cadence (present when sufficient data exists) */
+    cadence?: DataCadence;
+}
+/** Options for symbol coverage query */
+interface SymbolCoverageOptions {
+    /** Start of gap detection window (Unix milliseconds). Default: now - 30 days */
+    from?: number;
+    /** End of gap detection window (Unix milliseconds). Default: now */
+    to?: number;
 }
 /** Per-symbol coverage response */
 interface SymbolCoverageResponse {
@@ -1203,6 +1223,37 @@ declare class OrderBookResource {
      * ```
      */
     createReconstructor(): OrderBookReconstructor;
+    /**
+     * Iterate over tick-level orderbook history with automatic pagination (Enterprise tier only).
+     *
+     * This async generator automatically handles pagination, fetching up to 1,000 deltas
+     * 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 params - Time range parameters
+     * @param depth - Maximum price levels to include in output snapshots
+     * @yields Reconstructed orderbook snapshots
+     *
+     * @example
+     * ```typescript
+     * // Process 24 hours of tick data with automatic pagination
+     * for await (const snapshot of client.lighter.orderbook.iterateTickHistory('BTC', {
+     *   start: Date.now() - 86400000,
+     *   end: Date.now()
+     * })) {
+     *   console.log(snapshot.timestamp, 'Mid:', snapshot.midPrice);
+     *   if (someCondition) break; // Early exit supported
+     * }
+     *
+     * // Collect all snapshots (caution: may use significant memory for large ranges)
+     * const allSnapshots: ReconstructedOrderBook[] = [];
+     * for await (const snapshot of client.lighter.orderbook.iterateTickHistory('BTC', { start, end })) {
+     *   allSnapshots.push(snapshot);
+     * }
+     * ```
+     */
+    iterateTickHistory(coin: string, params: TickHistoryParams, depth?: number): AsyncGenerator<ReconstructedOrderBook, void, undefined>;
 }
 
 /**
@@ -1627,11 +1678,13 @@ declare class DataQualityResource {
     /**
      * Get data coverage for a specific symbol on an exchange
      *
-     * Includes gap detection showing periods where data may be missing.
+     * Includes gap detection, empirical data cadence, and hour-level historical coverage.
+     * Supports optional time bounds for gap detection (default: last 30 days).
      *
      * @param exchange - Exchange name ('hyperliquid' or 'lighter')
      * @param symbol - Symbol name (e.g., 'BTC', 'ETH')
-     * @returns SymbolCoverageResponse with per-data-type coverage including gaps
+     * @param options - Optional time bounds for gap detection window
+     * @returns SymbolCoverageResponse with per-data-type coverage including gaps, cadence, and historical coverage
      *
      * @example
      * ```typescript
@@ -1642,9 +1695,21 @@ declare class DataQualityResource {
      * for (const gap of oi.gaps.slice(0, 3)) {
      *   console.log(`  ${gap.durationMinutes} min gap at ${gap.start}`);
      * }
+     *
+     * // Check cadence
+     * if (btc.dataTypes.orderbook.cadence) {
+     *   console.log(`Cadence: ~${btc.dataTypes.orderbook.cadence.medianIntervalSeconds}s`);
+     * }
+     *
+     * // Time-bounded (last 7 days)
+     * const weekAgo = Date.now() - 7 * 24 * 60 * 60 * 1000;
+     * const btc7d = await client.dataQuality.symbolCoverage('hyperliquid', 'BTC', {
+     *   from: weekAgo,
+     *   to: Date.now(),
+     * });
      * ```
      */
-    symbolCoverage(exchange: string, symbol: string): Promise<SymbolCoverageResponse>;
+    symbolCoverage(exchange: string, symbol: string, options?: SymbolCoverageOptions): Promise<SymbolCoverageResponse>;
     /**
      * List incidents with filtering and pagination
      *
@@ -3964,4 +4029,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 CompletenessMetrics, type CoverageGap, type CoverageResponse, type CursorResponse, type DataFreshness, type DataTypeCoverage, type DataTypeStatus, type ExchangeCoverage, type ExchangeLatency, type ExchangeStatus, type FundingRate, FundingRateArrayResponseSchema, FundingRateResponseSchema, FundingRateSchema, type GetOrderBookParams, type GetTradesCursorParams, 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 LiquidationsByUserParams, type ListIncidentsParams, type OpenInterest, OpenInterestArrayResponseSchema, OpenInterestResponseSchema, OpenInterestSchema, type OrderBook, OrderBookArrayResponseSchema, type OrderBookHistoryParams, OrderBookReconstructor, OrderBookResponseSchema, OrderBookSchema, type OrderbookDelta, OxArchive, OxArchiveError, OxArchiveWs, type Pagination, type PriceLevel, PriceLevelSchema, type ReconstructOptions, type ReconstructedOrderBook, type RestApiLatency, type SlaActual, type SlaParams, type SlaResponse, type SlaTargets, type StatusResponse, 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 WebSocketLatency, type WsChannel, WsChannelSchema, type WsClientMessage, type WsConnectionState, WsConnectionStateSchema, type WsData, WsDataSchema, type WsError, WsErrorSchema, type WsEventHandlers, 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 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 CompletenessMetrics, type CoverageGap, type CoverageResponse, type CursorResponse, type DataCadence, type DataFreshness, type DataTypeCoverage, type DataTypeStatus, type ExchangeCoverage, type ExchangeLatency, type ExchangeStatus, type FundingRate, FundingRateArrayResponseSchema, FundingRateResponseSchema, FundingRateSchema, type GetOrderBookParams, type GetTradesCursorParams, 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 LiquidationsByUserParams, type ListIncidentsParams, type OpenInterest, OpenInterestArrayResponseSchema, OpenInterestResponseSchema, OpenInterestSchema, type OrderBook, OrderBookArrayResponseSchema, type OrderBookHistoryParams, OrderBookReconstructor, OrderBookResponseSchema, OrderBookSchema, type OrderbookDelta, OxArchive, OxArchiveError, OxArchiveWs, type Pagination, type PriceLevel, PriceLevelSchema, type ReconstructOptions, type ReconstructedOrderBook, type RestApiLatency, 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 WebSocketLatency, type WsChannel, WsChannelSchema, type WsClientMessage, type WsConnectionState, WsConnectionStateSchema, type WsData, WsDataSchema, type WsError, WsErrorSchema, type WsEventHandlers, 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 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 };

package/dist/index.d.ts

@@ -671,6 +671,15 @@ interface CoverageGap {
     /** Duration of the gap in minutes */
     durationMinutes: number;
 }
+/** Empirical data cadence measurement based on last 7 days of data */
+interface DataCadence {
+    /** Median interval between consecutive records in seconds */
+    medianIntervalSeconds: number;
+    /** 95th percentile interval between consecutive records in seconds */
+    p95IntervalSeconds: number;
+    /** Number of intervals sampled for this measurement */
+    sampleCount: number;
+}
 /** Coverage for a specific symbol and data type */
 interface SymbolDataTypeCoverage {
     /** Earliest available data timestamp */
@@ -679,10 +688,21 @@ interface SymbolDataTypeCoverage {
     latest: string;
     /** Total number of records */
     totalRecords: number;
-    /** Completeness percentage (0-100) */
+    /** 24-hour completeness percentage (0-100) */
     completeness: number;
-    /** Detected data gaps */
+    /** Historical coverage percentage (0-100) based on hours with data / total hours */
+    historicalCoverage?: number;
+    /** Detected data gaps within the requested time window */
     gaps: CoverageGap[];
+    /** Empirical data cadence (present when sufficient data exists) */
+    cadence?: DataCadence;
+}
+/** Options for symbol coverage query */
+interface SymbolCoverageOptions {
+    /** Start of gap detection window (Unix milliseconds). Default: now - 30 days */
+    from?: number;
+    /** End of gap detection window (Unix milliseconds). Default: now */
+    to?: number;
 }
 /** Per-symbol coverage response */
 interface SymbolCoverageResponse {
@@ -1203,6 +1223,37 @@ declare class OrderBookResource {
      * ```
      */
     createReconstructor(): OrderBookReconstructor;
+    /**
+     * Iterate over tick-level orderbook history with automatic pagination (Enterprise tier only).
+     *
+     * This async generator automatically handles pagination, fetching up to 1,000 deltas
+     * 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 params - Time range parameters
+     * @param depth - Maximum price levels to include in output snapshots
+     * @yields Reconstructed orderbook snapshots
+     *
+     * @example
+     * ```typescript
+     * // Process 24 hours of tick data with automatic pagination
+     * for await (const snapshot of client.lighter.orderbook.iterateTickHistory('BTC', {
+     *   start: Date.now() - 86400000,
+     *   end: Date.now()
+     * })) {
+     *   console.log(snapshot.timestamp, 'Mid:', snapshot.midPrice);
+     *   if (someCondition) break; // Early exit supported
+     * }
+     *
+     * // Collect all snapshots (caution: may use significant memory for large ranges)
+     * const allSnapshots: ReconstructedOrderBook[] = [];
+     * for await (const snapshot of client.lighter.orderbook.iterateTickHistory('BTC', { start, end })) {
+     *   allSnapshots.push(snapshot);
+     * }
+     * ```
+     */
+    iterateTickHistory(coin: string, params: TickHistoryParams, depth?: number): AsyncGenerator<ReconstructedOrderBook, void, undefined>;
 }
 
 /**
@@ -1627,11 +1678,13 @@ declare class DataQualityResource {
     /**
      * Get data coverage for a specific symbol on an exchange
      *
-     * Includes gap detection showing periods where data may be missing.
+     * Includes gap detection, empirical data cadence, and hour-level historical coverage.
+     * Supports optional time bounds for gap detection (default: last 30 days).
      *
      * @param exchange - Exchange name ('hyperliquid' or 'lighter')
      * @param symbol - Symbol name (e.g., 'BTC', 'ETH')
-     * @returns SymbolCoverageResponse with per-data-type coverage including gaps
+     * @param options - Optional time bounds for gap detection window
+     * @returns SymbolCoverageResponse with per-data-type coverage including gaps, cadence, and historical coverage
      *
      * @example
      * ```typescript
@@ -1642,9 +1695,21 @@ declare class DataQualityResource {
      * for (const gap of oi.gaps.slice(0, 3)) {
      *   console.log(`  ${gap.durationMinutes} min gap at ${gap.start}`);
      * }
+     *
+     * // Check cadence
+     * if (btc.dataTypes.orderbook.cadence) {
+     *   console.log(`Cadence: ~${btc.dataTypes.orderbook.cadence.medianIntervalSeconds}s`);
+     * }
+     *
+     * // Time-bounded (last 7 days)
+     * const weekAgo = Date.now() - 7 * 24 * 60 * 60 * 1000;
+     * const btc7d = await client.dataQuality.symbolCoverage('hyperliquid', 'BTC', {
+     *   from: weekAgo,
+     *   to: Date.now(),
+     * });
      * ```
      */
-    symbolCoverage(exchange: string, symbol: string): Promise<SymbolCoverageResponse>;
+    symbolCoverage(exchange: string, symbol: string, options?: SymbolCoverageOptions): Promise<SymbolCoverageResponse>;
     /**
      * List incidents with filtering and pagination
      *
@@ -3964,4 +4029,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 CompletenessMetrics, type CoverageGap, type CoverageResponse, type CursorResponse, type DataFreshness, type DataTypeCoverage, type DataTypeStatus, type ExchangeCoverage, type ExchangeLatency, type ExchangeStatus, type FundingRate, FundingRateArrayResponseSchema, FundingRateResponseSchema, FundingRateSchema, type GetOrderBookParams, type GetTradesCursorParams, 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 LiquidationsByUserParams, type ListIncidentsParams, type OpenInterest, OpenInterestArrayResponseSchema, OpenInterestResponseSchema, OpenInterestSchema, type OrderBook, OrderBookArrayResponseSchema, type OrderBookHistoryParams, OrderBookReconstructor, OrderBookResponseSchema, OrderBookSchema, type OrderbookDelta, OxArchive, OxArchiveError, OxArchiveWs, type Pagination, type PriceLevel, PriceLevelSchema, type ReconstructOptions, type ReconstructedOrderBook, type RestApiLatency, type SlaActual, type SlaParams, type SlaResponse, type SlaTargets, type StatusResponse, 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 WebSocketLatency, type WsChannel, WsChannelSchema, type WsClientMessage, type WsConnectionState, WsConnectionStateSchema, type WsData, WsDataSchema, type WsError, WsErrorSchema, type WsEventHandlers, 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 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 CompletenessMetrics, type CoverageGap, type CoverageResponse, type CursorResponse, type DataCadence, type DataFreshness, type DataTypeCoverage, type DataTypeStatus, type ExchangeCoverage, type ExchangeLatency, type ExchangeStatus, type FundingRate, FundingRateArrayResponseSchema, FundingRateResponseSchema, FundingRateSchema, type GetOrderBookParams, type GetTradesCursorParams, 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 LiquidationsByUserParams, type ListIncidentsParams, type OpenInterest, OpenInterestArrayResponseSchema, OpenInterestResponseSchema, OpenInterestSchema, type OrderBook, OrderBookArrayResponseSchema, type OrderBookHistoryParams, OrderBookReconstructor, OrderBookResponseSchema, OrderBookSchema, type OrderbookDelta, OxArchive, OxArchiveError, OxArchiveWs, type Pagination, type PriceLevel, PriceLevelSchema, type ReconstructOptions, type ReconstructedOrderBook, type RestApiLatency, 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 WebSocketLatency, type WsChannel, WsChannelSchema, type WsClientMessage, type WsConnectionState, WsConnectionStateSchema, type WsData, WsDataSchema, type WsError, WsErrorSchema, type WsEventHandlers, 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 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 };

package/dist/index.js

@@ -767,6 +767,72 @@ var OrderBookResource = class {
   createReconstructor() {
     return new OrderBookReconstructor();
   }
+  /**
+   * Iterate over tick-level orderbook history with automatic pagination (Enterprise tier only).
+   *
+   * This async generator automatically handles pagination, fetching up to 1,000 deltas
+   * 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 params - Time range parameters
+   * @param depth - Maximum price levels to include in output snapshots
+   * @yields Reconstructed orderbook snapshots
+   *
+   * @example
+   * ```typescript
+   * // Process 24 hours of tick data with automatic pagination
+   * for await (const snapshot of client.lighter.orderbook.iterateTickHistory('BTC', {
+   *   start: Date.now() - 86400000,
+   *   end: Date.now()
+   * })) {
+   *   console.log(snapshot.timestamp, 'Mid:', snapshot.midPrice);
+   *   if (someCondition) break; // Early exit supported
+   * }
+   *
+   * // Collect all snapshots (caution: may use significant memory for large ranges)
+   * const allSnapshots: ReconstructedOrderBook[] = [];
+   * for await (const snapshot of client.lighter.orderbook.iterateTickHistory('BTC', { start, end })) {
+   *   allSnapshots.push(snapshot);
+   * }
+   * ```
+   */
+  async *iterateTickHistory(coin, params, depth) {
+    const startTs = typeof params.start === "string" ? new Date(params.start).getTime() : params.start;
+    const endTs = typeof params.end === "string" ? new Date(params.end).getTime() : params.end;
+    let cursor = startTs;
+    const reconstructor = new OrderBookReconstructor();
+    const MAX_DELTAS_PER_PAGE = 1e3;
+    let isFirstPage = true;
+    while (cursor < endTs) {
+      const tickData = await this.historyTick(coin, {
+        start: cursor,
+        end: endTs,
+        depth: params.depth
+      });
+      if (tickData.deltas.length === 0) {
+        if (isFirstPage) {
+          reconstructor.initialize(tickData.checkpoint);
+          yield reconstructor.getSnapshot(depth);
+        }
+        break;
+      }
+      let skipFirst = !isFirstPage;
+      for (const snapshot of reconstructor.iterate(tickData.checkpoint, tickData.deltas, { depth })) {
+        if (skipFirst) {
+          skipFirst = false;
+          continue;
+        }
+        yield snapshot;
+      }
+      isFirstPage = false;
+      const lastDelta = tickData.deltas[tickData.deltas.length - 1];
+      cursor = lastDelta.timestamp + 1;
+      if (tickData.deltas.length < MAX_DELTAS_PER_PAGE) {
+        break;
+      }
+    }
+  }
 };
 
 // src/resources/trades.ts
@@ -1124,11 +1190,13 @@ var DataQualityResource = class {
   /**
    * Get data coverage for a specific symbol on an exchange
    *
-   * Includes gap detection showing periods where data may be missing.
+   * Includes gap detection, empirical data cadence, and hour-level historical coverage.
+   * Supports optional time bounds for gap detection (default: last 30 days).
    *
    * @param exchange - Exchange name ('hyperliquid' or 'lighter')
    * @param symbol - Symbol name (e.g., 'BTC', 'ETH')
-   * @returns SymbolCoverageResponse with per-data-type coverage including gaps
+   * @param options - Optional time bounds for gap detection window
+   * @returns SymbolCoverageResponse with per-data-type coverage including gaps, cadence, and historical coverage
    *
    * @example
    * ```typescript
@@ -1139,11 +1207,24 @@ var DataQualityResource = class {
    * for (const gap of oi.gaps.slice(0, 3)) {
    *   console.log(`  ${gap.durationMinutes} min gap at ${gap.start}`);
    * }
+   *
+   * // Check cadence
+   * if (btc.dataTypes.orderbook.cadence) {
+   *   console.log(`Cadence: ~${btc.dataTypes.orderbook.cadence.medianIntervalSeconds}s`);
+   * }
+   *
+   * // Time-bounded (last 7 days)
+   * const weekAgo = Date.now() - 7 * 24 * 60 * 60 * 1000;
+   * const btc7d = await client.dataQuality.symbolCoverage('hyperliquid', 'BTC', {
+   *   from: weekAgo,
+   *   to: Date.now(),
+   * });
    * ```
    */
-  async symbolCoverage(exchange, symbol) {
+  async symbolCoverage(exchange, symbol, options) {
     return this.http.get(
-      `${this.basePath}/coverage/${exchange.toLowerCase()}/${symbol.toUpperCase()}`
+      `${this.basePath}/coverage/${exchange.toLowerCase()}/${symbol.toUpperCase()}`,
+      options
     );
   }
   // ===========================================================================