@pear-protocol/market-sdk 0.0.13 → 0.0.14

package/dist/chart/ws/binance.js

@@ -1,42 +1,56 @@
 import { BaseCandleWs } from './base-candle';
 
-const toStreamName = (symbol, interval) => `${symbol.toLowerCase()}@kline_${interval}`;
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const toStreamName = /* @__PURE__ */ __name((symbol, interval) => `${symbol.toLowerCase()}@kline_${interval}`, "toStreamName");
 class BinanceCandleWs extends BaseCandleWs {
+  static {
+    __name(this, "BinanceCandleWs");
+  }
   idCounter = 1;
   buildSubscribeMessage(symbol, interval) {
     return {
       method: "SUBSCRIBE",
-      params: [toStreamName(symbol, interval)],
+      params: [
+        toStreamName(symbol, interval)
+      ],
       id: this.idCounter++
     };
   }
   buildUnsubscribeMessage(symbol, interval) {
     return {
       method: "UNSUBSCRIBE",
-      params: [toStreamName(symbol, interval)],
+      params: [
+        toStreamName(symbol, interval)
+      ],
       id: this.idCounter++
     };
   }
-  parseMessage(data) {
-    let msg;
+  /** Translates one Binance kline frame into a single-candle batch. */
+  parseMessages(data) {
+    let message;
     try {
-      msg = JSON.parse(data);
+      message = JSON.parse(data);
     } catch {
-      return null;
+      return [];
     }
-    if (msg.e !== "kline" || !msg.k) return null;
-    const k = msg.k;
-    return {
-      symbol: k.s,
-      candle: {
-        t: k.t,
-        T: k.T,
-        o: Number(k.o),
-        h: Number(k.h),
-        l: Number(k.l),
-        c: Number(k.c)
+    if (message.e !== "kline" || !message.k) {
+      return [];
+    }
+    const kline = message.k;
+    return [
+      {
+        symbol: kline.s,
+        candle: {
+          t: kline.t,
+          T: kline.T,
+          o: Number(kline.o),
+          h: Number(kline.h),
+          l: Number(kline.l),
+          c: Number(kline.c)
+        }
       }
-    };
+    ];
   }
 }
 

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

@@ -1,6 +1,6 @@
 import { WsMessage } from '../../shared/types.js';
-import { CandleInterval, CandleData } from '../types.js';
-import { BaseCandleWs } from './base-candle.js';
+import { CandleInterval } from '../types.js';
+import { BaseCandleWs, ParsedCandle } from './base-candle.js';
 import '../../transport/index.js';
 import '@pear-protocol/types';
 import '../../transport/base-transport.js';
@@ -9,10 +9,8 @@ import 'partysocket';
 declare class BybitCandleWs extends BaseCandleWs {
     protected buildSubscribeMessage(symbol: string, interval: CandleInterval): WsMessage;
     protected buildUnsubscribeMessage(symbol: string, interval: CandleInterval): WsMessage;
-    protected parseMessage(data: string): {
-        symbol: string;
-        candle: CandleData;
-    } | null;
+    /** Translates one Bybit kline frame into a single-candle batch. */
+    protected parseMessages(data: string): ParsedCandle[];
 }
 
 export { BybitCandleWs };

package/dist/chart/ws/bybit.js

@@ -1,5 +1,7 @@
 import { BaseCandleWs } from './base-candle';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 const intervalMap = {
   "1m": "1",
   "3m": "3",
@@ -16,47 +18,61 @@ const intervalMap = {
   "1w": "W",
   "1M": "M"
 };
-const toTopic = (symbol, interval) => `kline.${intervalMap[interval]}.${symbol}`;
-const fromTopic = (topic) => {
+const toTopic = /* @__PURE__ */ __name((symbol, interval) => `kline.${intervalMap[interval]}.${symbol}`, "toTopic");
+const fromTopic = /* @__PURE__ */ __name((topic) => {
   const parts = topic.split(".");
   return parts[2] ?? "";
-};
+}, "fromTopic");
 class BybitCandleWs extends BaseCandleWs {
+  static {
+    __name(this, "BybitCandleWs");
+  }
   buildSubscribeMessage(symbol, interval) {
     return {
       op: "subscribe",
-      args: [toTopic(symbol, interval)]
+      args: [
+        toTopic(symbol, interval)
+      ]
     };
   }
   buildUnsubscribeMessage(symbol, interval) {
     return {
       op: "unsubscribe",
-      args: [toTopic(symbol, interval)]
+      args: [
+        toTopic(symbol, interval)
+      ]
     };
   }
-  parseMessage(data) {
-    let msg;
+  /** Translates one Bybit kline frame into a single-candle batch. */
+  parseMessages(data) {
+    let message;
     try {
-      msg = JSON.parse(data);
+      message = JSON.parse(data);
     } catch {
-      return null;
+      return [];
     }
-    const topic = msg.topic;
-    const msgData = msg.data;
-    if (!topic || !msgData || !Array.isArray(msgData) || msgData.length === 0) return null;
-    if (!topic.startsWith("kline.")) return null;
-    const d = msgData[0];
-    return {
-      symbol: fromTopic(topic),
-      candle: {
-        t: d.start,
-        T: d.end,
-        o: Number(d.open),
-        h: Number(d.high),
-        l: Number(d.low),
-        c: Number(d.close)
+    const topic = message.topic;
+    const klines = message.data;
+    if (!topic || !klines || !Array.isArray(klines) || klines.length === 0) {
+      return [];
+    }
+    if (!topic.startsWith("kline.")) {
+      return [];
+    }
+    const kline = klines[0];
+    return [
+      {
+        symbol: fromTopic(topic),
+        candle: {
+          t: kline.start,
+          T: kline.end,
+          o: Number(kline.open),
+          h: Number(kline.high),
+          l: Number(kline.low),
+          c: Number(kline.close)
+        }
       }
-    };
+    ];
   }
 }
 

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

@@ -1,6 +1,6 @@
 import { WsMessage } from '../../shared/types.js';
-import { CandleInterval, CandleData } from '../types.js';
-import { BaseCandleWs } from './base-candle.js';
+import { CandleInterval } from '../types.js';
+import { BaseCandleWs, ParsedCandle } from './base-candle.js';
 import '../../transport/index.js';
 import '@pear-protocol/types';
 import '../../transport/base-transport.js';
@@ -22,10 +22,8 @@ interface HyperliquidUnsubscribeMessage extends WsMessage {
 declare class HyperliquidCandleWs extends BaseCandleWs {
     protected buildSubscribeMessage(symbol: string, interval: CandleInterval): HyperliquidSubscribeMessage;
     protected buildUnsubscribeMessage(symbol: string, interval: CandleInterval): HyperliquidUnsubscribeMessage;
-    protected parseMessage(data: string): {
-        symbol: string;
-        candle: CandleData;
-    } | null;
+    /** Translates one Hyperliquid candle frame into a single-candle batch. */
+    protected parseMessages(data: string): ParsedCandle[];
 }
 
 export { HyperliquidCandleWs };

package/dist/chart/ws/hyperliquid.js

@@ -1,39 +1,57 @@
 import { BaseCandleWs } from './base-candle';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 class HyperliquidCandleWs extends BaseCandleWs {
+  static {
+    __name(this, "HyperliquidCandleWs");
+  }
   buildSubscribeMessage(symbol, interval) {
     return {
       method: "subscribe",
-      subscription: { type: "candle", coin: symbol, interval }
+      subscription: {
+        type: "candle",
+        coin: symbol,
+        interval
+      }
     };
   }
   buildUnsubscribeMessage(symbol, interval) {
     return {
       method: "unsubscribe",
-      subscription: { type: "candle", coin: symbol, interval }
+      subscription: {
+        type: "candle",
+        coin: symbol,
+        interval
+      }
     };
   }
-  parseMessage(data) {
-    let msg;
+  /** Translates one Hyperliquid candle frame into a single-candle batch. */
+  parseMessages(data) {
+    let message;
     try {
-      msg = JSON.parse(data);
+      message = JSON.parse(data);
     } catch {
-      return null;
+      return [];
     }
-    if (msg.channel !== "candle" || !msg.data) return null;
-    const d = msg.data;
-    return {
-      symbol: d.s,
-      candle: {
-        s: d.s,
-        t: d.t,
-        T: d.T,
-        o: Number(d.o),
-        h: Number(d.h),
-        l: Number(d.l),
-        c: Number(d.c)
+    if (message.channel !== "candle" || !message.data) {
+      return [];
+    }
+    const payload = message.data;
+    return [
+      {
+        symbol: payload.s,
+        candle: {
+          s: payload.s,
+          t: payload.t,
+          T: payload.T,
+          o: Number(payload.o),
+          h: Number(payload.h),
+          l: Number(payload.l),
+          c: Number(payload.c)
+        }
       }
-    };
+    ];
   }
 }
 

package/dist/chart/ws/index.js

@@ -5,6 +5,8 @@ import { HyperliquidCandleWs } from './hyperliquid';
 import { LighterCandleWs } from './lighter';
 import { OkxCandleWs } from './okx';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 function createCandleWs(transport, connector, onCandle) {
   switch (connector) {
     case "hyperliquid":
@@ -23,5 +25,6 @@ function createCandleWs(transport, connector, onCandle) {
     }
   }
 }
+__name(createCandleWs, "createCandleWs");
 
 export { createCandleWs };

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

@@ -1,30 +1,30 @@
 import { WsMessage } from '../../shared/types.js';
-import { CandleInterval, CandleData } from '../types.js';
-import { BaseCandleWs } from './base-candle.js';
+import { CandleInterval } from '../types.js';
+import { BaseCandleWs, ParsedCandle } from './base-candle.js';
 import '../../transport/index.js';
 import '@pear-protocol/types';
 import '../../transport/base-transport.js';
 import 'partysocket';
 
+/**
+ * Lighter publishes ready-made OHLC candles on a dedicated channel, so this class only translates
+ * them onto CandleData — it never aggregates the trade tape and never seeds itself over REST, because
+ * the subscribe acknowledgement already carries the current live candle.
+ * Docs: https://apidocs.lighter.xyz/docs/websocket-reference#candlesticks
+ */
+
 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;
+    /** Subscribes to a market's candle stream; `symbol` is Lighter's numeric market id. */
+    protected buildSubscribeMessage(symbol: string, interval: CandleInterval): WsMessage;
+    /** Mirrors the subscribe channel — Lighter keys unsubscribes by the same slash-delimited name. */
+    protected buildUnsubscribeMessage(symbol: string, interval: CandleInterval): WsMessage;
+    /**
+     * Translates one candle message into CandleData, oldest first.
+     *
+     * Lighter batches updates every 500ms and, when a period rolls over, sends the just-closed candle
+     * followed by the newly opened one — both are emitted so the closed bar keeps its final trades.
+     */
+    protected parseMessages(data: string): ParsedCandle[];
 }
 
 export { LighterCandleWs };

package/dist/chart/ws/lighter.js

@@ -1,214 +1,93 @@
 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;
-}
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const SUPPORTED_RESOLUTIONS = /* @__PURE__ */ new Set([
+  "1m",
+  "5m",
+  "15m",
+  "30m",
+  "1h",
+  "4h",
+  "12h",
+  "1d"
+]);
 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}` };
+  static {
+    __name(this, "LighterCandleWs");
   }
-  parseMessage(_data) {
-    return null;
+  /** Subscribes to a market's candle stream; `symbol` is Lighter's numeric market id. */
+  buildSubscribeMessage(symbol, interval) {
+    return {
+      type: "subscribe",
+      channel: `candle/${symbol}/${interval}`
+    };
   }
-  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"));
-      }
-    }
+  /** Mirrors the subscribe channel — Lighter keys unsubscribes by the same slash-delimited name. */
+  buildUnsubscribeMessage(symbol, interval) {
+    return {
+      type: "unsubscribe",
+      channel: `candle/${symbol}/${interval}`
+    };
   }
-  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"));
-      }
+  /**
+  * Translates one candle message into CandleData, oldest first.
+  *
+  * Lighter batches updates every 500ms and, when a period rolls over, sends the just-closed candle
+  * followed by the newly opened one — both are emitted so the closed bar keeps its final trades.
+  */
+  parseMessages(data) {
+    let message;
+    try {
+      message = JSON.parse(data);
+    } catch {
+      return [];
     }
-    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);
+    if (message.type !== "subscribed/candle" && message.type !== "update/candle") {
+      return [];
     }
-    const isFirstForSymbol = intervals.size === 0;
-    intervals.add(interval);
-    if (isFirstForSymbol && this.transport.connected) {
-      this.transport.send(this.buildSubscribeMessage(symbol, interval));
+    if (!Array.isArray(message.candles) || message.candles.length === 0) {
+      return [];
     }
-    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));
-      }
+    const route = parseChannel(message.channel);
+    if (!route) {
+      return [];
     }
+    const intervalMs = getIntervalSeconds(route.interval) * 1e3;
+    return message.candles.map((candle) => ({
+      symbol: route.symbol,
+      candle: toCandleData(candle, intervalMs)
+    }));
   }
-  // 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);
-    }
+}
+function parseChannel(channel) {
+  if (!channel) {
+    return null;
   }
-  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 {
-    }
+  const [prefix, symbol, resolution] = channel.split(":");
+  if (prefix !== "candle" || !symbol || !resolution) {
+    return null;
   }
-  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
-        });
-      }
-    }
+  if (!SUPPORTED_RESOLUTIONS.has(resolution)) {
+    return null;
   }
+  return {
+    symbol,
+    interval: resolution
+  };
+}
+__name(parseChannel, "parseChannel");
+function toCandleData(candle, intervalMs) {
+  return {
+    t: candle.t,
+    T: candle.t + intervalMs - 1,
+    o: candle.o ?? 0,
+    h: candle.h ?? 0,
+    l: candle.l ?? 0,
+    c: candle.c ?? 0
+  };
 }
+__name(toCandleData, "toCandleData");
 
 export { LighterCandleWs };

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

@@ -1,6 +1,6 @@
 import { WsMessage } from '../../shared/types.js';
-import { CandleInterval, CandleData } from '../types.js';
-import { BaseCandleWs } from './base-candle.js';
+import { CandleInterval } from '../types.js';
+import { BaseCandleWs, ParsedCandle } from './base-candle.js';
 import '../../transport/index.js';
 import '@pear-protocol/types';
 import '../../transport/base-transport.js';
@@ -9,10 +9,8 @@ import 'partysocket';
 declare class OkxCandleWs extends BaseCandleWs {
     protected buildSubscribeMessage(symbol: string, interval: CandleInterval): WsMessage;
     protected buildUnsubscribeMessage(symbol: string, interval: CandleInterval): WsMessage;
-    protected parseMessage(data: string): {
-        symbol: string;
-        candle: CandleData;
-    } | null;
+    /** Translates one OKX candle frame into a single-candle batch. */
+    protected parseMessages(data: string): ParsedCandle[];
 }
 
 export { OkxCandleWs };