@pear-protocol/chart-sdk 0.0.1

package/dist/cache/index.d.ts

@@ -0,0 +1,17 @@
+import { CandleInterval, CandleData, HistoricalRange } from '../types.js';
+import '@pear-protocol/types';
+
+declare class CandleCache {
+    private historicalPriceData;
+    private loadingTokens;
+    addLoadingToken(symbol: string): void;
+    removeLoadingToken(symbol: string): void;
+    addHistoricalPriceData(symbol: string, interval: CandleInterval, candles: CandleData[], range: HistoricalRange): void;
+    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;
+    removeToken(symbol: string, interval: CandleInterval): void;
+    clear(): void;
+}
+
+export { CandleCache };

package/dist/cache/index.js

@@ -0,0 +1,101 @@
+import { createKey, mergeRanges, getIntervalSeconds } from '../utils';
+
+class CandleCache {
+  historicalPriceData = {};
+  loadingTokens = /* @__PURE__ */ new Set();
+  addLoadingToken(symbol) {
+    this.loadingTokens.add(symbol);
+  }
+  removeLoadingToken(symbol) {
+    this.loadingTokens.delete(symbol);
+  }
+  addHistoricalPriceData(symbol, interval, candles, range) {
+    const key = createKey(symbol, interval);
+    const existing = this.historicalPriceData[key];
+    if (!existing) {
+      const sortedCandles = [...candles].sort((a, b) => a.t - b.t);
+      const noDataBefore2 = sortedCandles.length === 0 ? range.end : null;
+      this.historicalPriceData[key] = {
+        symbol,
+        interval,
+        candles: sortedCandles,
+        oldestTime: sortedCandles.length > 0 ? sortedCandles[0]?.t ?? null : null,
+        latestTime: sortedCandles.length > 0 ? sortedCandles[sortedCandles.length - 1]?.t ?? null : null,
+        requestedRanges: [range],
+        noDataBefore: noDataBefore2
+      };
+      return;
+    }
+    const existingTimes = new Set(existing.candles.map((c) => c.t));
+    const newCandles = candles.filter((c) => !existingTimes.has(c.t));
+    const mergedCandles = [...existing.candles, ...newCandles].sort((a, b) => a.t - b.t);
+    const oldestTime = mergedCandles.length > 0 ? mergedCandles[0]?.t ?? null : null;
+    const latestTime = mergedCandles.length > 0 ? mergedCandles[mergedCandles.length - 1]?.t ?? null : null;
+    const mergedRanges = mergeRanges(existing.requestedRanges, range);
+    let noDataBefore = existing.noDataBefore;
+    if (candles.length === 0 && existing.oldestTime !== null && range.end <= existing.oldestTime) {
+      noDataBefore = existing.oldestTime;
+    }
+    this.historicalPriceData[key] = {
+      ...existing,
+      candles: mergedCandles,
+      oldestTime,
+      latestTime,
+      requestedRanges: mergedRanges,
+      noDataBefore
+    };
+  }
+  hasData(symbol, interval, startTime, endTime) {
+    const key = createKey(symbol, interval);
+    const tokenData = this.historicalPriceData[key];
+    if (!tokenData) return false;
+    if (tokenData.noDataBefore !== null && endTime <= tokenData.noDataBefore) {
+      return true;
+    }
+    for (const range of tokenData.requestedRanges) {
+      if (range.start <= startTime && range.end >= endTime) {
+        return true;
+      }
+    }
+    if (tokenData.oldestTime === null || tokenData.latestTime === null) {
+      return false;
+    }
+    const intervalMs = getIntervalSeconds(interval) * 1e3;
+    const hasStartCoverage = tokenData.oldestTime <= startTime;
+    const hasEndCoverage = tokenData.latestTime >= endTime || tokenData.latestTime + intervalMs >= endTime;
+    return hasStartCoverage && hasEndCoverage;
+  }
+  getData(symbol, interval, startTime, endTime) {
+    const key = createKey(symbol, interval);
+    const tokenData = this.historicalPriceData[key];
+    if (!tokenData) return [];
+    return tokenData.candles.filter((candle) => candle.t >= startTime && candle.t < endTime);
+  }
+  getEffectiveBoundary(symbols, interval) {
+    if (symbols.length === 0) return null;
+    let maxBoundary = null;
+    for (const symbol of symbols) {
+      const key = createKey(symbol, interval);
+      const tokenData = this.historicalPriceData[key];
+      if (!tokenData) continue;
+      const boundary = tokenData.noDataBefore ?? tokenData.oldestTime;
+      if (boundary !== null) {
+        if (maxBoundary === null || boundary > maxBoundary) {
+          maxBoundary = boundary;
+        }
+      }
+    }
+    return maxBoundary;
+  }
+  removeToken(symbol, interval) {
+    const key = createKey(symbol, interval);
+    delete this.historicalPriceData[key];
+    this.loadingTokens.delete(symbol);
+  }
+  clear() {
+    this.historicalPriceData = {};
+    this.loadingTokens = /* @__PURE__ */ new Set();
+  }
+}
+
+export { CandleCache };

package/dist/chart.d.ts

@@ -0,0 +1,21 @@
+import { Connector } from '@pear-protocol/types';
+import { ChartConfig, TokenSelection, CandleInterval, ChartType, Bar, RealtimeBarCallback } from './types.js';
+
+declare class Chart {
+    private collector;
+    private subscriptions;
+    private baselinePrices;
+    constructor(config?: ChartConfig);
+    setTokens(longTokens: TokenSelection[], shortTokens: TokenSelection[]): void;
+    setCandleInterval(interval: CandleInterval): void;
+    setExchange(connector: Connector): void;
+    getBars(chartType: ChartType, startTime: number, endTime: number): Promise<Bar[]>;
+    getAssetBars(symbol: string, startTime: number, endTime: number): Promise<Bar[]>;
+    getEffectiveDataBoundary(): number | null;
+    subscribeRealtimeBars(chartType: ChartType, callback: RealtimeBarCallback): string;
+    unsubscribeRealtimeBars(id: string): void;
+    clearCache(): void;
+    destroy(): void;
+}
+
+export { Chart };

package/dist/chart.js

@@ -0,0 +1,119 @@
+import { DataCollector } from './collector';
+import { computePerformanceCandles, computePriceRatioCandles, computeWeightedRatioCandles, computeAssetBars, computeRealtimePerformanceBar, computeRealtimePriceRatioBar, computeRealtimeWeightedRatioBar } from './compute/index';
+
+class Chart {
+  collector;
+  subscriptions = /* @__PURE__ */ new Map();
+  baselinePrices = {};
+  constructor(config) {
+    this.collector = new DataCollector(config);
+  }
+  setTokens(longTokens, shortTokens) {
+    this.collector.setTokens(longTokens, shortTokens);
+    this.baselinePrices = {};
+  }
+  setCandleInterval(interval) {
+    this.collector.setCandleInterval(interval);
+    this.baselinePrices = {};
+  }
+  setExchange(connector) {
+    this.collector.setExchange(connector);
+    this.baselinePrices = {};
+  }
+  async getBars(chartType, startTime, endTime) {
+    const interval = this.collector.getCandleInterval();
+    const tokenCandles = await this.collector.fetchHistoricalPriceData(startTime, endTime, interval);
+    switch (chartType) {
+      case "weighted-ratio": {
+        return computeWeightedRatioCandles(
+          this.collector.getLongTokens(),
+          this.collector.getShortTokens(),
+          tokenCandles
+        );
+      }
+      case "price-ratio": {
+        return computePriceRatioCandles(this.collector.getLongTokens(), this.collector.getShortTokens(), tokenCandles);
+      }
+      case "performance": {
+        const result = computePerformanceCandles(
+          this.collector.getLongTokens(),
+          this.collector.getShortTokens(),
+          tokenCandles
+        );
+        if (result.bars.length > 0) {
+          this.baselinePrices = result.baselinePrices;
+        }
+        return result.bars;
+      }
+    }
+  }
+  async getAssetBars(symbol, startTime, endTime) {
+    const interval = this.collector.getCandleInterval();
+    const tokenCandles = await this.collector.fetchHistoricalPriceData(startTime, endTime, interval);
+    return computeAssetBars(tokenCandles, symbol);
+  }
+  getEffectiveDataBoundary() {
+    return this.collector.getEffectiveDataBoundary(this.collector.getCandleInterval());
+  }
+  subscribeRealtimeBars(chartType, callback) {
+    if (!this.collector.isWsConnected) {
+      this.collector.connectWs();
+    }
+    const rawListenerId = this.collector.addRealtimeListener(() => {
+      const snapshot = this.collector.getLatestCandles();
+      if (!snapshot) return;
+      let bar = null;
+      switch (chartType) {
+        case "weighted-ratio":
+          bar = computeRealtimeWeightedRatioBar(
+            this.collector.getLongTokens(),
+            this.collector.getShortTokens(),
+            snapshot
+          );
+          break;
+        case "price-ratio":
+          bar = computeRealtimePriceRatioBar(this.collector.getLongTokens(), this.collector.getShortTokens(), snapshot);
+          break;
+        case "performance":
+          if (Object.keys(this.baselinePrices).length === 0) break;
+          bar = computeRealtimePerformanceBar(
+            this.collector.getLongTokens(),
+            this.collector.getShortTokens(),
+            snapshot,
+            this.baselinePrices
+          );
+          break;
+      }
+      if (bar) {
+        try {
+          callback(bar);
+        } catch {
+        }
+      }
+    });
+    const id = Math.random().toString(36).slice(2);
+    this.subscriptions.set(id, { chartType, callback, rawListenerId });
+    return id;
+  }
+  unsubscribeRealtimeBars(id) {
+    const sub = this.subscriptions.get(id);
+    if (!sub) return;
+    this.collector.removeRealtimeListener(sub.rawListenerId);
+    this.subscriptions.delete(id);
+    if (this.subscriptions.size === 0) {
+      this.collector.disconnectWs();
+    }
+  }
+  clearCache() {
+    this.collector.clearCache();
+    this.baselinePrices = {};
+  }
+  destroy() {
+    for (const [id] of this.subscriptions) {
+      this.unsubscribeRealtimeBars(id);
+    }
+    this.collector.destroy();
+  }
+}
+
+export { Chart };

package/dist/collector/binance.d.ts

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

package/dist/collector/binance.js

@@ -0,0 +1,27 @@
+const BINANCE_FUTURES_URL = "https://fapi.binance.com/fapi/v1/klines";
+const MAX_LIMIT = 1e3;
+function toCandleData(kline) {
+  return {
+    t: kline[0],
+    T: kline[6],
+    o: Number(kline[1]),
+    h: Number(kline[2]),
+    l: Number(kline[3]),
+    c: Number(kline[4])
+  };
+}
+async function fetchHistoricalCandles(symbol, startTime, endTime, interval) {
+  const params = new URLSearchParams({
+    symbol,
+    interval,
+    startTime: String(startTime),
+    endTime: String(endTime),
+    limit: String(MAX_LIMIT)
+  });
+  const response = await fetch(`${BINANCE_FUTURES_URL}?${params}`);
+  if (!response.ok) throw new Error(`Binance API error: ${response.status} ${response.statusText}`);
+  const data = await response.json();
+  return data.map(toCandleData);
+}
+
+export { fetchHistoricalCandles };

package/dist/collector/bybit.d.ts

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

package/dist/collector/bybit.js

@@ -0,0 +1,39 @@
+const BYBIT_URL = "https://api.bybit.com/v5/market/kline";
+const MAX_LIMIT = 1e3;
+const intervalMap = {
+  "1m": "1",
+  "3m": "3",
+  "5m": "5",
+  "15m": "15",
+  "30m": "30",
+  "1h": "60",
+  "2h": "120",
+  "4h": "240",
+  "8h": "480",
+  "12h": "720",
+  "1d": "D",
+  "3d": "D",
+  "1w": "W",
+  "1M": "M"
+};
+function toCandleData(item) {
+  const startMs = Number(item[0]);
+  return { t: startMs, T: startMs, o: Number(item[1]), h: Number(item[2]), l: Number(item[3]), c: Number(item[4]) };
+}
+async function fetchHistoricalCandles(symbol, startTime, endTime, interval) {
+  const params = new URLSearchParams({
+    category: "linear",
+    symbol,
+    interval: intervalMap[interval],
+    start: String(startTime),
+    end: String(endTime),
+    limit: String(MAX_LIMIT)
+  });
+  const response = await fetch(`${BYBIT_URL}?${params}`);
+  if (!response.ok) throw new Error(`Bybit API error: ${response.status} ${response.statusText}`);
+  const data = await response.json();
+  if (data.retCode !== 0) throw new Error(`Bybit API error: ${data.retMsg}`);
+  return data.result.list.reverse().map((item) => toCandleData(item));
+}
+
+export { fetchHistoricalCandles };

package/dist/collector/helpers.d.ts

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

package/dist/collector/helpers.js

@@ -0,0 +1,21 @@
+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';
+
+async function fetchHistoricalCandles(connector, symbol, startTime, endTime, interval) {
+  switch (connector) {
+    case "hyperliquid":
+      return fetchHistoricalCandles$4(symbol, startTime, endTime, interval);
+    case "binanceusdm":
+      return fetchHistoricalCandles$3(symbol, startTime, endTime, interval);
+    case "bybit":
+      return fetchHistoricalCandles$2(symbol, startTime, endTime, interval);
+    case "okx":
+      return fetchHistoricalCandles$1(symbol, startTime, endTime, interval);
+    default:
+      throw new Error(`Unsupported connector: ${connector}`);
+  }
+}
+
+export { fetchHistoricalCandles };

package/dist/collector/hyperliquid.d.ts

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

package/dist/collector/hyperliquid.js

@@ -0,0 +1,15 @@
+async function fetchHistoricalCandles(symbol, startTime, endTime, interval) {
+  const request = {
+    req: { coin: symbol, startTime, endTime, interval },
+    type: "candleSnapshot"
+  };
+  const response = await fetch("https://api.hyperliquid.xyz/info", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(request)
+  });
+  if (!response.ok) throw new Error(`Hyperliquid API error: ${response.status} ${response.statusText}`);
+  return response.json();
+}
+
+export { fetchHistoricalCandles };

package/dist/collector/index.d.ts

@@ -0,0 +1,39 @@
+import { Connector } from '@pear-protocol/types';
+import { ChartConfig, TokenSelection, CandleInterval, RealtimeCandleCallback, CandleData } from '../types.js';
+
+declare class DataCollector {
+    private longTokens;
+    private shortTokens;
+    private candleInterval;
+    private exchange;
+    private prevTokenSymbols;
+    private prevInterval;
+    private exchangeWs;
+    private candleWs;
+    private latestCandles;
+    private realtimeListeners;
+    private cache;
+    constructor(config?: ChartConfig);
+    setTokens(longTokens: TokenSelection[], shortTokens: TokenSelection[]): void;
+    setCandleInterval(interval: CandleInterval): void;
+    setExchange(connector: Connector): void;
+    connectWs(): void;
+    disconnectWs(): void;
+    get isWsConnected(): boolean;
+    addRealtimeListener(cb: RealtimeCandleCallback): string;
+    removeRealtimeListener(id: string): void;
+    getLatestCandles(): Record<string, CandleData> | null;
+    getLongTokens(): TokenSelection[];
+    getShortTokens(): TokenSelection[];
+    getCandleInterval(): CandleInterval;
+    getEffectiveDataBoundary(interval: CandleInterval): number | null;
+    clearCache(): void;
+    fetchHistoricalPriceData(startTime: number, endTime: number, interval: CandleInterval, callback?: (data: Record<string, CandleData[]>) => void): Promise<Record<string, CandleData[]>>;
+    destroy(): void;
+    private getAllTokens;
+    private syncTokenChanges;
+    private getHistoricalPriceData;
+    private syncWsSubscriptions;
+}
+
+export { DataCollector };

package/dist/collector/index.js

@@ -0,0 +1,211 @@
+import { CandleCache } from '../cache';
+import { createCandleWs } from '../ws';
+import { fetchHistoricalCandles } from './helpers';
+
+class DataCollector {
+  longTokens;
+  shortTokens;
+  candleInterval;
+  exchange;
+  prevTokenSymbols = /* @__PURE__ */ new Set();
+  prevInterval = null;
+  exchangeWs = null;
+  candleWs = null;
+  latestCandles = /* @__PURE__ */ new Map();
+  realtimeListeners = /* @__PURE__ */ new Map();
+  cache = new CandleCache();
+  constructor(config) {
+    this.longTokens = config?.longTokens ?? [];
+    this.shortTokens = config?.shortTokens ?? [];
+    this.candleInterval = config?.candleInterval ?? "1h";
+    this.exchange = config?.connector ?? "hyperliquid";
+    this.syncTokenChanges();
+  }
+  setTokens(longTokens, shortTokens) {
+    this.longTokens = longTokens;
+    this.shortTokens = shortTokens;
+    this.syncTokenChanges();
+    this.syncWsSubscriptions();
+  }
+  setCandleInterval(interval) {
+    const prevInterval = this.candleInterval;
+    this.candleInterval = interval;
+    this.syncTokenChanges();
+    if (this.candleWs && prevInterval !== interval) {
+      for (const symbol of this.prevTokenSymbols) {
+        this.candleWs.unsubscribe(symbol, prevInterval);
+      }
+      this.latestCandles.clear();
+      for (const symbol of this.prevTokenSymbols) {
+        this.candleWs.subscribe(symbol, interval);
+      }
+    }
+  }
+  setExchange(connector) {
+    if (this.exchange === connector) return;
+    const wasStreaming = this.candleWs !== null;
+    this.disconnectWs();
+    this.exchange = connector;
+    this.latestCandles.clear();
+    this.cache.clear();
+    if (wasStreaming) {
+      this.connectWs();
+    }
+  }
+  connectWs() {
+    if (this.candleWs) return;
+    const bundle = createCandleWs(this.exchange, (symbol, candle) => {
+      this.latestCandles.set(symbol, candle);
+      for (const cb of this.realtimeListeners.values()) {
+        try {
+          cb(symbol, candle);
+        } catch {
+        }
+      }
+    });
+    this.exchangeWs = bundle.exchangeWs;
+    this.candleWs = bundle.candleWs;
+    this.exchangeWs.connect();
+    this.candleWs.start();
+    for (const token of this.getAllTokens()) {
+      this.candleWs.subscribe(token.symbol, this.candleInterval);
+    }
+  }
+  disconnectWs() {
+    if (this.candleWs) {
+      this.candleWs.stop();
+      this.candleWs = null;
+    }
+    if (this.exchangeWs) {
+      this.exchangeWs.disconnect();
+      this.exchangeWs = null;
+    }
+  }
+  get isWsConnected() {
+    return this.exchangeWs?.connected ?? false;
+  }
+  addRealtimeListener(cb) {
+    const id = Math.random().toString(36).slice(2);
+    this.realtimeListeners.set(id, cb);
+    return id;
+  }
+  removeRealtimeListener(id) {
+    this.realtimeListeners.delete(id);
+  }
+  getLatestCandles() {
+    const allTokens = this.getAllTokens();
+    if (allTokens.length === 0) return null;
+    const result = {};
+    for (const token of allTokens) {
+      const candle = this.latestCandles.get(token.symbol);
+      if (!candle) return null;
+      result[token.symbol] = candle;
+    }
+    return result;
+  }
+  getLongTokens() {
+    return this.longTokens;
+  }
+  getShortTokens() {
+    return this.shortTokens;
+  }
+  getCandleInterval() {
+    return this.candleInterval;
+  }
+  getEffectiveDataBoundary(interval) {
+    const symbols = this.getAllTokens().map((t) => t.symbol);
+    return this.cache.getEffectiveBoundary(symbols, interval);
+  }
+  clearCache() {
+    this.cache.clear();
+    this.latestCandles.clear();
+  }
+  async fetchHistoricalPriceData(startTime, endTime, interval, callback) {
+    const allTokens = this.getAllTokens();
+    if (allTokens.length === 0) {
+      const emptyResult = {};
+      callback?.(emptyResult);
+      return emptyResult;
+    }
+    const tokensToFetch = allTokens.filter((token) => !this.cache.hasData(token.symbol, interval, startTime, endTime));
+    if (tokensToFetch.length === 0) {
+      const cachedData = this.getHistoricalPriceData(startTime, endTime, interval);
+      callback?.(cachedData);
+      return cachedData;
+    }
+    for (const token of tokensToFetch) {
+      this.cache.addLoadingToken(token.symbol);
+    }
+    try {
+      const fetchPromises = tokensToFetch.map(async (token) => {
+        try {
+          const candles = await fetchHistoricalCandles(this.exchange, token.symbol, startTime, endTime, interval);
+          this.cache.addHistoricalPriceData(token.symbol, interval, candles, { start: startTime, end: endTime });
+          return { symbol: token.symbol, candles, success: true };
+        } catch (error) {
+          console.warn(`Failed to fetch historical data for ${token.symbol}:`, error);
+          return { symbol: token.symbol, candles: [], success: false };
+        }
+      });
+      await Promise.all(fetchPromises);
+      const allData = this.getHistoricalPriceData(startTime, endTime, interval);
+      callback?.(allData);
+      return allData;
+    } catch (error) {
+      console.error("Failed to fetch historical data:", error);
+      throw error;
+    } finally {
+      for (const token of tokensToFetch) {
+        this.cache.removeLoadingToken(token.symbol);
+      }
+    }
+  }
+  destroy() {
+    this.disconnectWs();
+    this.realtimeListeners.clear();
+    this.latestCandles.clear();
+    this.cache.clear();
+  }
+  getAllTokens() {
+    return [...this.longTokens, ...this.shortTokens];
+  }
+  syncTokenChanges() {
+    const currentSymbols = new Set(this.getAllTokens().map((t) => t.symbol));
+    if (this.prevInterval !== null && this.prevInterval !== this.candleInterval) {
+      this.cache.clear();
+      this.prevTokenSymbols = currentSymbols;
+      this.prevInterval = this.candleInterval;
+      return;
+    }
+    for (const symbol of this.prevTokenSymbols) {
+      if (!currentSymbols.has(symbol)) {
+        this.cache.removeToken(symbol, this.candleInterval);
+      }
+    }
+    this.prevTokenSymbols = currentSymbols;
+    this.prevInterval = this.candleInterval;
+  }
+  getHistoricalPriceData(startTime, endTime, interval) {
+    const allTokens = this.getAllTokens();
+    const result = {};
+    for (const token of allTokens) {
+      result[token.symbol] = this.cache.getData(token.symbol, interval, startTime, endTime);
+    }
+    return result;
+  }
+  syncWsSubscriptions() {
+    if (!this.candleWs) return;
+    const currentSymbols = new Set(this.getAllTokens().map((t) => t.symbol));
+    for (const [symbol] of this.latestCandles) {
+      if (!currentSymbols.has(symbol)) {
+        this.candleWs.unsubscribe(symbol, this.candleInterval);
+        this.latestCandles.delete(symbol);
+      }
+    }
+    for (const symbol of currentSymbols) {
+      this.candleWs.subscribe(symbol, this.candleInterval);
+    }
+  }
+}
+
+export { DataCollector };

package/dist/collector/okx.d.ts

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