@pear-protocol/market-sdk 0.0.2 → 0.0.4

package/dist/chart/cache/index.d.ts

@@ -14,6 +14,7 @@ declare class CandleCache {
     hasData(symbol: string, interval: CandleInterval, startTime: number, endTime: number): boolean;
     getData(symbol: string, interval: CandleInterval, startTime: number, endTime: number): CandleData[];
     getEffectiveBoundary(symbols: string[], interval: CandleInterval): number | null;
+    getLatestCandle(symbol: string, interval: CandleInterval): CandleData | null;
     removeToken(symbol: string, interval: CandleInterval): void;
     clear(): void;
 }

package/dist/chart/cache/index.js

@@ -87,6 +87,12 @@ class CandleCache {
     }
     return maxBoundary;
   }
+  getLatestCandle(symbol, interval) {
+    const key = createKey(symbol, interval);
+    const tokenData = this.historicalPriceData[key];
+    if (!tokenData || tokenData.candles.length === 0) return null;
+    return tokenData.candles[tokenData.candles.length - 1] ?? null;
+  }
   removeToken(symbol, interval) {
     const key = createKey(symbol, interval);
     delete this.historicalPriceData[key];

package/dist/chart/collector/helpers.js

@@ -1,17 +1,20 @@
-import { fetchHistoricalCandles as fetchHistoricalCandles$3 } from './binance';
-import { fetchHistoricalCandles as fetchHistoricalCandles$2 } from './bybit';
-import { fetchHistoricalCandles as fetchHistoricalCandles$4 } from './hyperliquid';
-import { fetchHistoricalCandles as fetchHistoricalCandles$1 } from './okx';
+import { fetchHistoricalCandles as fetchHistoricalCandles$4 } from './binance';
+import { fetchHistoricalCandles as fetchHistoricalCandles$3 } from './bybit';
+import { fetchHistoricalCandles as fetchHistoricalCandles$5 } from './hyperliquid';
+import { fetchHistoricalCandles as fetchHistoricalCandles$1 } from './lighter';
+import { fetchHistoricalCandles as fetchHistoricalCandles$2 } from './okx';
 
 async function fetchHistoricalCandles(connector, symbol, startTime, endTime, interval) {
   switch (connector) {
     case "hyperliquid":
-      return fetchHistoricalCandles$4(symbol, startTime, endTime, interval);
+      return fetchHistoricalCandles$5(symbol, startTime, endTime, interval);
     case "binance":
-      return fetchHistoricalCandles$3(symbol, startTime, endTime, interval);
+      return fetchHistoricalCandles$4(symbol, startTime, endTime, interval);
     case "bybit":
-      return fetchHistoricalCandles$2(symbol, startTime, endTime, interval);
+      return fetchHistoricalCandles$3(symbol, startTime, endTime, interval);
     case "okx":
+      return fetchHistoricalCandles$2(symbol, startTime, endTime, interval);
+    case "lighter":
       return fetchHistoricalCandles$1(symbol, startTime, endTime, interval);
     default:
       throw new Error(`Unsupported connector: ${connector}`);

package/dist/chart/collector/index.js

@@ -54,6 +54,10 @@ class DataCollector {
     });
     this.candleWs.start();
     for (const token of this.getAllTokens()) {
+      const latestCandle = this.cache.getLatestCandle(token.symbol, this.candleInterval);
+      if (latestCandle) {
+        this.candleWs.onHistoricalDataFetched(token.symbol, this.candleInterval, [latestCandle]);
+      }
       this.candleWs.subscribe(token.symbol, this.candleInterval);
     }
   }
@@ -127,6 +131,7 @@ class DataCollector {
             interval
           );
           this.cache.addHistoricalPriceData(token.symbol, interval, candles, { start: startTime, end: endTime });
+          this.candleWs?.onHistoricalDataFetched(token.symbol, interval, candles);
           return { symbol: token.symbol, candles, success: true };
         } catch (error) {
           console.warn(`Failed to fetch historical data for ${token.symbol}:`, error);

package/dist/chart/collector/lighter.d.ts

@@ -0,0 +1,10 @@
+import { CandleInterval, CandleData } from '../types.js';
+import '../../transport/index.js';
+import '@pear-protocol/types';
+import '../../transport/base-transport.js';
+import 'partysocket';
+import '../../shared/types.js';
+
+declare function fetchHistoricalCandles(symbol: string, startTime: number, endTime: number, interval: CandleInterval): Promise<CandleData[]>;
+
+export { fetchHistoricalCandles };

package/dist/chart/collector/lighter.js

@@ -0,0 +1,42 @@
+import { getIntervalSeconds } from '../utils';
+
+const BASE_URL = "https://mainnet.zklighter.elliot.ai";
+const MAX_LIMIT = 500;
+const RESOLUTION_MAP = {
+  "1m": "1m",
+  "5m": "5m",
+  "15m": "15m",
+  "30m": "30m",
+  "1h": "1h",
+  "4h": "4h",
+  "12h": "12h",
+  "1d": "1d",
+  "1w": "1w"
+};
+async function fetchHistoricalCandles(symbol, startTime, endTime, interval) {
+  const resolution = RESOLUTION_MAP[interval];
+  if (!resolution) throw new Error(`Lighter does not support the '${interval}' interval`);
+  const intervalMs = getIntervalSeconds(interval) * 1e3;
+  const countBack = Math.min(Math.ceil((endTime - startTime) / intervalMs) + 1, MAX_LIMIT);
+  const params = new URLSearchParams({
+    market_id: symbol,
+    resolution,
+    start_timestamp: String(startTime),
+    end_timestamp: String(endTime),
+    count_back: String(countBack)
+  });
+  const response = await fetch(`${BASE_URL}/api/v1/candles?${params}`);
+  if (!response.ok) throw new Error(`Lighter API error: ${response.status} ${response.statusText}`);
+  const data = await response.json();
+  if (data.code !== 200) throw new Error(`Lighter API error: ${data.message ?? String(data.code)}`);
+  return data.c.map((candle) => ({
+    t: candle.t,
+    T: candle.t + intervalMs - 1,
+    o: candle.o ?? 0,
+    h: candle.h ?? 0,
+    l: candle.l ?? 0,
+    c: candle.c ?? 0
+  }));
+}
+
+export { fetchHistoricalCandles };

package/dist/chart/ws/base-candle.d.ts

@@ -1,6 +1,6 @@
 import { WsMessage } from '../../shared/types.js';
 import { BaseTransport } from '../../transport/base-transport.js';
-import { CandleInterval, CandleData } from '../types.js';
+import { CandleData, CandleInterval } from '../types.js';
 import '@pear-protocol/types';
 import 'partysocket';
 import '../../transport/index.js';
@@ -8,7 +8,7 @@ import '../../transport/index.js';
 type CandleHandler = (symbol: string, candle: CandleData) => void;
 declare abstract class BaseCandleWs {
     protected transport: BaseTransport;
-    private onCandle;
+    protected onCandle: CandleHandler;
     private messageListenerId;
     private openListenerId;
     private subscribedKeys;
@@ -23,6 +23,7 @@ declare abstract class BaseCandleWs {
     stop(): void;
     get connected(): boolean;
     subscribe(symbol: string, interval: CandleInterval): void;
+    onHistoricalDataFetched(_symbol: string, _interval: CandleInterval, _candles: CandleData[]): void;
     unsubscribe(symbol: string, interval: CandleInterval): void;
 }
 

package/dist/chart/ws/base-candle.js

@@ -58,6 +58,10 @@ class BaseCandleWs {
       this.transport.send(this.buildSubscribeMessage(symbol, interval));
     }
   }
+  // Called by DataCollector after historical candles are fetched. Implementations may use this
+  // to seed their realtime state so the first WS update builds on the correct open/high/low.
+  onHistoricalDataFetched(_symbol, _interval, _candles) {
+  }
   unsubscribe(symbol, interval) {
     const key = `${symbol}::${interval}`;
     if (!this.subscribedKeys.has(key)) return;

package/dist/chart/ws/index.js

@@ -2,6 +2,7 @@ export { BaseCandleWs } from './base-candle';
 import { BinanceCandleWs } from './binance';
 import { BybitCandleWs } from './bybit';
 import { HyperliquidCandleWs } from './hyperliquid';
+import { LighterCandleWs } from './lighter';
 import { OkxCandleWs } from './okx';
 
 function createCandleWs(transport, connector, onCandle) {
@@ -14,6 +15,8 @@ function createCandleWs(transport, connector, onCandle) {
       return new BybitCandleWs(transport, onCandle);
     case "okx":
       return new OkxCandleWs(transport, onCandle);
+    case "lighter":
+      return new LighterCandleWs(transport, onCandle);
     default: {
       const _exhaustive = connector;
       throw new Error(`Unsupported exchange: ${String(_exhaustive)}`);

package/dist/chart/ws/lighter.d.ts

@@ -0,0 +1,30 @@
+import { WsMessage } from '../../shared/types.js';
+import { CandleInterval, CandleData } from '../types.js';
+import { BaseCandleWs } from './base-candle.js';
+import '../../transport/index.js';
+import '@pear-protocol/types';
+import '../../transport/base-transport.js';
+import 'partysocket';
+
+declare class LighterCandleWs extends BaseCandleWs {
+    private symbolIntervals;
+    private candleState;
+    private ownMessageListenerId;
+    private ownOpenListenerId;
+    protected buildSubscribeMessage(symbol: string, _interval: CandleInterval): WsMessage;
+    protected buildUnsubscribeMessage(symbol: string, _interval: CandleInterval): WsMessage;
+    protected parseMessage(_data: string): {
+        symbol: string;
+        candle: CandleData;
+    } | null;
+    start(): void;
+    stop(): void;
+    subscribe(symbol: string, interval: CandleInterval): void;
+    unsubscribe(symbol: string, interval: CandleInterval): void;
+    onHistoricalDataFetched(symbol: string, interval: CandleInterval, candles: CandleData[]): void;
+    private applyCandleState;
+    private seedFromHistory;
+    private handleTradeMessage;
+}
+
+export { LighterCandleWs };

package/dist/chart/ws/lighter.js

@@ -0,0 +1,214 @@
+import { getIntervalSeconds } from '../utils';
+import { BaseCandleWs } from './base-candle';
+
+const LIGHTER_BASE_URL = "https://mainnet.zklighter.elliot.ai";
+const RESOLUTION_MAP = {
+  "1m": "1m",
+  "5m": "5m",
+  "15m": "15m",
+  "30m": "30m",
+  "1h": "1h",
+  "4h": "4h",
+  "12h": "12h",
+  "1d": "1d",
+  "1w": "1w"
+};
+function toIntervalOpenTime(ts, intervalMs) {
+  return Math.floor(ts / intervalMs) * intervalMs;
+}
+class LighterCandleWs extends BaseCandleWs {
+  symbolIntervals = /* @__PURE__ */ new Map();
+  candleState = /* @__PURE__ */ new Map();
+  ownMessageListenerId = null;
+  ownOpenListenerId = null;
+  buildSubscribeMessage(symbol, _interval) {
+    return { type: "subscribe", channel: `trade/${symbol}` };
+  }
+  buildUnsubscribeMessage(symbol, _interval) {
+    return { type: "unsubscribe", channel: `trade/${symbol}` };
+  }
+  parseMessage(_data) {
+    return null;
+  }
+  start() {
+    if (this.ownMessageListenerId) return;
+    this.ownMessageListenerId = this.transport.addMessageListener((data) => {
+      this.handleTradeMessage(data);
+    });
+    this.ownOpenListenerId = this.transport.addOpenListener(() => {
+      this.candleState.clear();
+      for (const [symbol, intervals] of this.symbolIntervals) {
+        this.transport.send(this.buildSubscribeMessage(symbol, "1m"));
+        for (const interval of intervals) {
+          void this.seedFromHistory(symbol, interval);
+        }
+      }
+    });
+    if (!this.transport.connected) {
+      this.transport.connect();
+    } else {
+      for (const symbol of this.symbolIntervals.keys()) {
+        this.transport.send(this.buildSubscribeMessage(symbol, "1m"));
+      }
+    }
+  }
+  stop() {
+    if (this.ownMessageListenerId) {
+      this.transport.removeMessageListener(this.ownMessageListenerId);
+      this.ownMessageListenerId = null;
+    }
+    if (this.ownOpenListenerId) {
+      this.transport.removeOpenListener(this.ownOpenListenerId);
+      this.ownOpenListenerId = null;
+    }
+    if (this.transport.connected) {
+      for (const symbol of this.symbolIntervals.keys()) {
+        this.transport.send(this.buildUnsubscribeMessage(symbol, "1m"));
+      }
+    }
+    this.symbolIntervals.clear();
+    this.candleState.clear();
+    super.stop();
+  }
+  subscribe(symbol, interval) {
+    let intervals = this.symbolIntervals.get(symbol);
+    if (!intervals) {
+      intervals = /* @__PURE__ */ new Set();
+      this.symbolIntervals.set(symbol, intervals);
+    }
+    const isFirstForSymbol = intervals.size === 0;
+    intervals.add(interval);
+    if (isFirstForSymbol && this.transport.connected) {
+      this.transport.send(this.buildSubscribeMessage(symbol, interval));
+    }
+    void this.seedFromHistory(symbol, interval);
+  }
+  unsubscribe(symbol, interval) {
+    const intervals = this.symbolIntervals.get(symbol);
+    if (!intervals) return;
+    intervals.delete(interval);
+    if (intervals.size === 0) {
+      this.symbolIntervals.delete(symbol);
+      this.candleState.delete(symbol);
+      if (this.transport.connected) {
+        this.transport.send(this.buildUnsubscribeMessage(symbol, interval));
+      }
+    }
+  }
+  // Called before subscribe() in attachCandleWs so seedFromHistory can skip its fetch when
+  // the current period is already covered by historical data.
+  onHistoricalDataFetched(symbol, interval, candles) {
+    if (candles.length === 0) return;
+    const lastCandle = candles[candles.length - 1];
+    if (!lastCandle) return;
+    const intervalMs = getIntervalSeconds(interval) * 1e3;
+    if (lastCandle.t !== toIntervalOpenTime(Date.now(), intervalMs)) return;
+    this.applyCandleState(symbol, interval, {
+      openTime: lastCandle.t,
+      closeTime: lastCandle.T,
+      open: lastCandle.o,
+      high: lastCandle.h,
+      low: lastCandle.l,
+      close: lastCandle.c
+    });
+  }
+  applyCandleState(symbol, interval, state) {
+    let symbolState = this.candleState.get(symbol);
+    if (!symbolState) {
+      symbolState = /* @__PURE__ */ new Map();
+      this.candleState.set(symbol, symbolState);
+    }
+    const existing = symbolState.get(interval);
+    if (!existing || existing.openTime !== state.openTime) {
+      symbolState.set(interval, state);
+    }
+  }
+  async seedFromHistory(symbol, interval) {
+    const resolution = RESOLUTION_MAP[interval];
+    if (!resolution) return;
+    const intervalMs = getIntervalSeconds(interval) * 1e3;
+    const now = Date.now();
+    const openTime = toIntervalOpenTime(now, intervalMs);
+    if (this.candleState.get(symbol)?.get(interval)?.openTime === openTime) return;
+    try {
+      const params = new URLSearchParams({
+        market_id: symbol,
+        resolution,
+        start_timestamp: String(openTime),
+        end_timestamp: String(now),
+        count_back: "1"
+      });
+      const response = await fetch(`${LIGHTER_BASE_URL}/api/v1/candles?${params}`);
+      if (!response.ok) return;
+      const data = await response.json();
+      if (data.code !== 200 || !data.c?.length) return;
+      const candle = data.c[data.c.length - 1];
+      if (!this.symbolIntervals.get(symbol)?.has(interval)) return;
+      this.applyCandleState(symbol, interval, {
+        openTime: candle.t,
+        closeTime: candle.t + intervalMs - 1,
+        open: candle.o ?? 0,
+        high: candle.h ?? 0,
+        low: candle.l ?? 0,
+        close: candle.c ?? 0
+      });
+    } catch {
+    }
+  }
+  handleTradeMessage(data) {
+    let msg;
+    try {
+      msg = JSON.parse(data);
+    } catch {
+      console.log("Received non-JSON message from Lighter WS, ignoring:", data);
+      return;
+    }
+    if (msg.type !== "update/trade") return;
+    if (!Array.isArray(msg.trades) || msg.trades.length === 0) return;
+    const colonIdx = msg.channel.indexOf(":");
+    if (colonIdx === -1 || !msg.channel.startsWith("trade")) return;
+    const symbol = msg.channel.slice(colonIdx + 1);
+    const intervals = this.symbolIntervals.get(symbol);
+    if (!intervals || intervals.size === 0) return;
+    let symbolState = this.candleState.get(symbol);
+    if (!symbolState) {
+      symbolState = /* @__PURE__ */ new Map();
+      this.candleState.set(symbol, symbolState);
+    }
+    const intervalMsMap = /* @__PURE__ */ new Map();
+    for (const interval of intervals) {
+      intervalMsMap.set(interval, getIntervalSeconds(interval) * 1e3);
+    }
+    for (const trade of msg.trades) {
+      const price = Number(trade.price);
+      const ts = trade.timestamp;
+      for (const interval of intervals) {
+        const intervalMs = intervalMsMap.get(interval);
+        if (intervalMs === void 0) continue;
+        const openTime = toIntervalOpenTime(ts, intervalMs);
+        const closeTime = openTime + intervalMs - 1;
+        const existing = symbolState.get(interval);
+        let state;
+        if (!existing || existing.openTime !== openTime) {
+          state = { openTime, closeTime, open: price, high: price, low: price, close: price };
+          symbolState.set(interval, state);
+        } else {
+          if (price > existing.high) existing.high = price;
+          if (price < existing.low) existing.low = price;
+          existing.close = price;
+          state = existing;
+        }
+        this.onCandle(symbol, {
+          t: state.openTime,
+          T: state.closeTime,
+          o: state.open,
+          h: state.high,
+          l: state.low,
+          c: state.close
+        });
+      }
+    }
+  }
+}
+
+export { LighterCandleWs };

package/dist/orderbook/ws/index.js

@@ -2,6 +2,7 @@ export { BaseDepthWs } from './base-depth';
 import { BinanceDepthWs } from './binance';
 import { BybitDepthWs } from './bybit';
 import { HyperliquidDepthWs } from './hyperliquid';
+import { LighterDepthWs } from './lighter';
 import { OkxDepthWs } from './okx';
 
 function createDepthWs(transport, connector, onUpdate) {
@@ -14,6 +15,8 @@ function createDepthWs(transport, connector, onUpdate) {
       return new BybitDepthWs(transport, onUpdate);
     case "okx":
       return new OkxDepthWs(transport, onUpdate);
+    case "lighter":
+      return new LighterDepthWs(transport, onUpdate);
     default: {
       const _exhaustive = connector;
       throw new Error(`Unsupported exchange: ${String(_exhaustive)}`);

package/dist/orderbook/ws/lighter.d.ts

@@ -0,0 +1,21 @@
+import { WsMessage } from '../../shared/types.js';
+import { DepthUpdate } from '../types.js';
+import { BaseDepthWs } from './base-depth.js';
+import '../../transport/index.js';
+import '@pear-protocol/types';
+import '../../transport/base-transport.js';
+import 'partysocket';
+
+declare class LighterDepthWs extends BaseDepthWs {
+    private snapshotReceived;
+    private lastNonce;
+    private resetListenerId;
+    protected buildSubscribeMessage(symbol: string): WsMessage;
+    protected buildUnsubscribeMessage(symbol: string): WsMessage;
+    start(): void;
+    stop(): void;
+    protected parseMessage(data: string): DepthUpdate | null;
+    private resubscribe;
+}
+
+export { LighterDepthWs };

package/dist/orderbook/ws/lighter.js

@@ -0,0 +1,72 @@
+import { BaseDepthWs, parseStringLevels } from './base-depth';
+
+class LighterDepthWs extends BaseDepthWs {
+  snapshotReceived = /* @__PURE__ */ new Map();
+  lastNonce = /* @__PURE__ */ new Map();
+  resetListenerId = null;
+  buildSubscribeMessage(symbol) {
+    return { type: "subscribe", channel: `order_book@tier2/${symbol}` };
+  }
+  buildUnsubscribeMessage(symbol) {
+    return { type: "unsubscribe", channel: `order_book@tier2/${symbol}` };
+  }
+  start() {
+    super.start();
+    this.resetListenerId = this.transport.addOpenListener(() => {
+      this.snapshotReceived.clear();
+      this.lastNonce.clear();
+    });
+  }
+  stop() {
+    if (this.resetListenerId) {
+      this.transport.removeOpenListener(this.resetListenerId);
+      this.resetListenerId = null;
+    }
+    this.snapshotReceived.clear();
+    this.lastNonce.clear();
+    super.stop();
+  }
+  parseMessage(data) {
+    let msg;
+    try {
+      msg = JSON.parse(data);
+    } catch {
+      return null;
+    }
+    if (msg.type === "pong") return null;
+    if (msg.type !== "update/order_book" && msg.type !== "subscribed/order_book") return null;
+    const colonIdx = msg.channel.indexOf(":");
+    if (colonIdx === -1 || !msg.channel.startsWith("order_book")) return null;
+    const symbol = msg.channel.slice(colonIdx + 1);
+    const book = msg.order_book;
+    if (!book || book.code !== 0) return null;
+    const isSnapshot = !this.snapshotReceived.get(symbol);
+    if (!isSnapshot) {
+      const prevNonce = this.lastNonce.get(symbol);
+      if (prevNonce !== void 0 && book.begin_nonce !== prevNonce) {
+        console.warn(
+          `[LighterDepthWs] Sequence break on symbol ${symbol}: expected begin_nonce ${prevNonce}, got ${book.begin_nonce}. Resubscribing.`
+        );
+        this.resubscribe(symbol);
+        return null;
+      }
+    }
+    this.snapshotReceived.set(symbol, true);
+    this.lastNonce.set(symbol, book.nonce);
+    return {
+      symbol,
+      type: isSnapshot ? "snapshot" : "delta",
+      bids: parseStringLevels(book.bids.map((l) => [l.price, l.size])),
+      asks: parseStringLevels(book.asks.map((l) => [l.price, l.size])),
+      ts: msg.timestamp
+    };
+  }
+  resubscribe(symbol) {
+    this.snapshotReceived.delete(symbol);
+    this.lastNonce.delete(symbol);
+    this.transport.send(this.buildUnsubscribeMessage(symbol));
+    this.transport.send(this.buildSubscribeMessage(symbol));
+  }
+}
+
+export { LighterDepthWs };

package/dist/transport/index.js

@@ -2,6 +2,7 @@ export { BaseTransport } from './base-transport';
 import { BinanceTransport } from './binance';
 import { BybitTransport } from './bybit';
 import { HyperliquidTransport } from './hyperliquid';
+import { LighterTransport } from './lighter';
 import { OkxTransport } from './okx';
 
 function CreateTransport(connector) {
@@ -14,6 +15,8 @@ function CreateTransport(connector) {
       return new OkxTransport();
     case "hyperliquid":
       return new HyperliquidTransport();
+    case "lighter":
+      return new LighterTransport();
     default: {
       const _exhaustive = connector;
       throw new Error(`Unsupported connector: ${String(_exhaustive)}`);

package/dist/transport/lighter.d.ts

@@ -0,0 +1,13 @@
+import { Connector } from '@pear-protocol/types';
+import { WsMessage } from '../shared/types.js';
+import { BaseTransport } from './base-transport.js';
+import 'partysocket';
+
+declare class LighterTransport extends BaseTransport {
+    readonly connector: Connector;
+    protected getWsUrl(): string;
+    protected getPingIntervalMs(): number;
+    protected buildPingMessage(): WsMessage;
+}
+
+export { LighterTransport };

package/dist/transport/lighter.js

@@ -0,0 +1,16 @@
+import { BaseTransport } from './base-transport';
+
+class LighterTransport extends BaseTransport {
+  connector = "lighter";
+  getWsUrl() {
+    return "wss://mainnet.zklighter.elliot.ai/stream";
+  }
+  getPingIntervalMs() {
+    return 6e4;
+  }
+  buildPingMessage() {
+    return { type: "ping" };
+  }
+}
+
+export { LighterTransport };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pear-protocol/market-sdk",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Pear Protocol Market SDK",
   "private": false,
   "type": "module",
@@ -25,7 +25,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@pear-protocol/types": "0.0.13",
+    "@pear-protocol/types": "0.0.15",
     "bignumber.js": "^9.1.2",
     "partysocket": "^1.0.3"
   },