@pear-protocol/chart-sdk 0.0.1

package/dist/collector/okx.js

@@ -0,0 +1,38 @@
+const OKX_URL = "https://www.okx.com/api/v5/market/candles";
+const MAX_LIMIT = 300;
+const intervalMap = {
+  "1m": "1m",
+  "3m": "3m",
+  "5m": "5m",
+  "15m": "15m",
+  "30m": "30m",
+  "1h": "1H",
+  "2h": "2H",
+  "4h": "4H",
+  "8h": "8H",
+  "12h": "12H",
+  "1d": "1D",
+  "3d": "3D",
+  "1w": "1W",
+  "1M": "1M"
+};
+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(instId, startTime, endTime, interval) {
+  const params = new URLSearchParams({
+    instId,
+    bar: intervalMap[interval],
+    before: String(startTime),
+    after: String(endTime),
+    limit: String(MAX_LIMIT)
+  });
+  const response = await fetch(`${OKX_URL}?${params}`);
+  if (!response.ok) throw new Error(`OKX API error: ${response.status} ${response.statusText}`);
+  const data = await response.json();
+  if (data.code !== "0") throw new Error(`OKX API error: ${data.msg}`);
+  return data.data.reverse().map(toCandleData);
+}
+
+export { fetchHistoricalCandles };

package/dist/compute/asset.d.ts

@@ -0,0 +1,6 @@
+import { CandleData, Bar } from '../types.js';
+import '@pear-protocol/types';
+
+declare function computeAssetBars(tokenCandles: Record<string, CandleData[]>, symbol: string): Bar[];
+
+export { computeAssetBars };

package/dist/compute/asset.js

@@ -0,0 +1,13 @@
+function computeAssetBars(tokenCandles, symbol) {
+  const candles = tokenCandles[symbol];
+  if (!candles) return [];
+  return candles.map((c) => ({
+    time: c.t,
+    open: c.o,
+    high: c.h,
+    low: c.l,
+    close: c.c
+  }));
+}
+
+export { computeAssetBars };

package/dist/compute/index.d.ts

@@ -0,0 +1,6 @@
+export { computeAssetBars } from './asset.js';
+export { computePerformanceCandles, computeRealtimePerformanceBar } from './performance.js';
+export { computePriceRatioCandles, computeRealtimePriceRatioBar } from './price-ratio.js';
+export { computeRealtimeWeightedRatioBar, computeWeightedRatioCandles } from './weighted-ratio.js';
+import '../types.js';
+import '@pear-protocol/types';

package/dist/compute/index.js

@@ -0,0 +1,4 @@
+export { computeAssetBars } from './asset';
+export { computePerformanceCandles, computeRealtimePerformanceBar } from './performance';
+export { computePriceRatioCandles, computeRealtimePriceRatioBar } from './price-ratio';
+export { computeRealtimeWeightedRatioBar, computeWeightedRatioCandles } from './weighted-ratio';

package/dist/compute/performance.d.ts

@@ -0,0 +1,7 @@
+import { TokenSelection, CandleData, PerformanceResult, Bar } from '../types.js';
+import '@pear-protocol/types';
+
+declare function computePerformanceCandles(longTokens: TokenSelection[], shortTokens: TokenSelection[], tokenCandles: Record<string, CandleData[]>): PerformanceResult;
+declare function computeRealtimePerformanceBar(longTokens: TokenSelection[], shortTokens: TokenSelection[], snapshot: Record<string, CandleData>, baselinePrices: Record<string, number>): Bar | null;
+
+export { computePerformanceCandles, computeRealtimePerformanceBar };

package/dist/compute/performance.js

@@ -0,0 +1,81 @@
+import { createCandleLookups, getCompleteTimestamps } from '../utils';
+
+function computePerformanceCandles(longTokens, shortTokens, tokenCandles) {
+  const empty = { bars: [], baselinePrices: {} };
+  const allTokens = [...longTokens, ...shortTokens];
+  if (allTokens.length === 0) return empty;
+  const candleLookups = createCandleLookups(tokenCandles);
+  const allSymbols = allTokens.map((t) => t.symbol);
+  const completeTimestamps = getCompleteTimestamps(candleLookups, allSymbols);
+  if (completeTimestamps.length === 0) return empty;
+  const baselinePrices = {};
+  const firstTimestamp = completeTimestamps[0];
+  for (const token of allTokens) {
+    const candle = candleLookups[token.symbol]?.get(firstTimestamp);
+    if (!candle || candle.o <= 0) return empty;
+    baselinePrices[token.symbol] = candle.o;
+  }
+  const initialPortfolioValue = 1e3;
+  const longSet = new Set(longTokens.map((t) => t.symbol));
+  const bars = [];
+  for (const timestamp of completeTimestamps) {
+    let portfolioValue = 0;
+    let missing = false;
+    for (const token of allTokens) {
+      const candle = candleLookups[token.symbol]?.get(timestamp);
+      if (!candle) {
+        missing = true;
+        break;
+      }
+      const baselinePrice = baselinePrices[token.symbol];
+      const allocation = token.weight / 100 * initialPortfolioValue;
+      const priceRatio = candle.c / baselinePrice;
+      if (longSet.has(token.symbol)) {
+        portfolioValue += allocation * priceRatio;
+      } else {
+        portfolioValue += allocation / priceRatio;
+      }
+    }
+    if (missing) continue;
+    bars.push({
+      time: timestamp,
+      open: portfolioValue,
+      high: portfolioValue,
+      low: portfolioValue,
+      close: portfolioValue
+    });
+  }
+  return { bars, baselinePrices };
+}
+function computeRealtimePerformanceBar(longTokens, shortTokens, snapshot, baselinePrices) {
+  const allTokens = [...longTokens, ...shortTokens];
+  if (allTokens.length === 0) return null;
+  const initialPortfolioValue = 1e3;
+  const longSet = new Set(longTokens.map((t) => t.symbol));
+  let portfolioValue = 0;
+  let time = null;
+  for (const token of allTokens) {
+    const c = snapshot[token.symbol];
+    if (!c) return null;
+    const baselinePrice = baselinePrices[token.symbol];
+    if (!baselinePrice || baselinePrice <= 0) return null;
+    const allocation = token.weight / 100 * initialPortfolioValue;
+    const priceRatio = c.c / baselinePrice;
+    if (longSet.has(token.symbol)) {
+      portfolioValue += allocation * priceRatio;
+    } else {
+      portfolioValue += allocation / priceRatio;
+    }
+    if (time === null) time = c.t;
+  }
+  if (time === null) return null;
+  return {
+    time,
+    open: portfolioValue,
+    high: portfolioValue,
+    low: portfolioValue,
+    close: portfolioValue
+  };
+}
+
+export { computePerformanceCandles, computeRealtimePerformanceBar };

package/dist/compute/price-ratio.d.ts

@@ -0,0 +1,7 @@
+import { TokenSelection, CandleData, Bar } from '../types.js';
+import '@pear-protocol/types';
+
+declare function computePriceRatioCandles(longTokens: TokenSelection[], shortTokens: TokenSelection[], tokenCandles: Record<string, CandleData[]>): Bar[];
+declare function computeRealtimePriceRatioBar(longTokens: TokenSelection[], shortTokens: TokenSelection[], snapshot: Record<string, CandleData>): Bar | null;
+
+export { computePriceRatioCandles, computeRealtimePriceRatioBar };

package/dist/compute/price-ratio.js

@@ -0,0 +1,107 @@
+import { createCandleLookups, getCompleteTimestamps } from '../utils';
+
+function computePriceRatioCandles(longTokens, shortTokens, tokenCandles) {
+  if (longTokens.length === 0 && shortTokens.length === 0) return [];
+  const candleLookups = createCandleLookups(tokenCandles);
+  const allSymbols = [...longTokens, ...shortTokens].map((t) => t.symbol);
+  const completeTimestamps = getCompleteTimestamps(candleLookups, allSymbols);
+  const bars = [];
+  for (const timestamp of completeTimestamps) {
+    let longSumO = 0;
+    let longSumH = 0;
+    let longSumL = 0;
+    let longSumC = 0;
+    let shortSumO = 0;
+    let shortSumH = 0;
+    let shortSumL = 0;
+    let shortSumC = 0;
+    let missing = false;
+    for (const token of longTokens) {
+      const candle = candleLookups[token.symbol]?.get(timestamp);
+      if (!candle) {
+        missing = true;
+        break;
+      }
+      if (!(candle.o > 0 && candle.h > 0 && candle.l > 0 && candle.c > 0)) {
+        missing = true;
+        break;
+      }
+      const w = token.weight / 100;
+      longSumO += candle.o * w;
+      longSumH += candle.h * w;
+      longSumL += candle.l * w;
+      longSumC += candle.c * w;
+    }
+    if (missing) continue;
+    for (const token of shortTokens) {
+      const candle = candleLookups[token.symbol]?.get(timestamp);
+      if (!candle) {
+        missing = true;
+        break;
+      }
+      if (!(candle.o > 0 && candle.h > 0 && candle.l > 0 && candle.c > 0)) {
+        missing = true;
+        break;
+      }
+      const w = token.weight / 100;
+      shortSumO += candle.o * w;
+      shortSumH += candle.h * w;
+      shortSumL += candle.l * w;
+      shortSumC += candle.c * w;
+    }
+    if (missing) continue;
+    if (shortSumO <= 0 || shortSumH <= 0 || shortSumL <= 0 || shortSumC <= 0) continue;
+    bars.push({
+      time: timestamp,
+      open: longSumO / shortSumO,
+      high: longSumH / shortSumH,
+      low: longSumL / shortSumL,
+      close: longSumC / shortSumC
+    });
+  }
+  return bars;
+}
+function computeRealtimePriceRatioBar(longTokens, shortTokens, snapshot) {
+  let longSumO = 0;
+  let longSumH = 0;
+  let longSumL = 0;
+  let longSumC = 0;
+  let shortSumO = 0;
+  let shortSumH = 0;
+  let shortSumL = 0;
+  let shortSumC = 0;
+  let time = null;
+  for (const token of longTokens) {
+    const c = snapshot[token.symbol];
+    if (!c) return null;
+    if (!(c.o > 0 && c.h > 0 && c.l > 0 && c.c > 0)) return null;
+    const w = token.weight / 100;
+    longSumO += c.o * w;
+    longSumH += c.h * w;
+    longSumL += c.l * w;
+    longSumC += c.c * w;
+    if (time === null) time = c.t;
+  }
+  for (const token of shortTokens) {
+    const c = snapshot[token.symbol];
+    if (!c) return null;
+    if (!(c.o > 0 && c.h > 0 && c.l > 0 && c.c > 0)) return null;
+    const w = token.weight / 100;
+    shortSumO += c.o * w;
+    shortSumH += c.h * w;
+    shortSumL += c.l * w;
+    shortSumC += c.c * w;
+    if (time === null) time = c.t;
+  }
+  if (time === null) return null;
+  if (shortSumO <= 0 || shortSumH <= 0 || shortSumL <= 0 || shortSumC <= 0) return null;
+  return {
+    time,
+    open: longSumO / shortSumO,
+    high: longSumH / shortSumH,
+    low: longSumL / shortSumL,
+    close: longSumC / shortSumC
+  };
+}
+
+export { computePriceRatioCandles, computeRealtimePriceRatioBar };

package/dist/compute/weighted-ratio.d.ts

@@ -0,0 +1,7 @@
+import { TokenSelection, CandleData, Bar } from '../types.js';
+import '@pear-protocol/types';
+
+declare function computeWeightedRatioCandles(longTokens: TokenSelection[], shortTokens: TokenSelection[], tokenCandles: Record<string, CandleData[]>): Bar[];
+declare function computeRealtimeWeightedRatioBar(longTokens: TokenSelection[], shortTokens: TokenSelection[], snapshot: Record<string, CandleData>): Bar | null;
+
+export { computeRealtimeWeightedRatioBar, computeWeightedRatioCandles };

package/dist/compute/weighted-ratio.js

@@ -0,0 +1,105 @@
+import { createCandleLookups, getCompleteTimestamps } from '../utils';
+
+function computeWeightedRatioCandles(longTokens, shortTokens, tokenCandles) {
+  if (longTokens.length === 0 && shortTokens.length === 0) return [];
+  const candleLookups = createCandleLookups(tokenCandles);
+  const allSymbols = [...longTokens, ...shortTokens].map((t) => t.symbol);
+  const completeTimestamps = getCompleteTimestamps(candleLookups, allSymbols);
+  const bars = [];
+  for (const timestamp of completeTimestamps) {
+    let longOpen = 1;
+    let longHigh = 1;
+    let longLow = 1;
+    let longClose = 1;
+    let shortOpen = 1;
+    let shortHigh = 1;
+    let shortLow = 1;
+    let shortClose = 1;
+    let missing = false;
+    for (const token of longTokens) {
+      const candle = candleLookups[token.symbol]?.get(timestamp);
+      if (!candle) {
+        missing = true;
+        break;
+      }
+      const w = token.weight / 100;
+      if (!(candle.o > 0 && candle.h > 0 && candle.l > 0 && candle.c > 0)) {
+        missing = true;
+        break;
+      }
+      longOpen *= candle.o ** w;
+      longHigh *= candle.h ** w;
+      longLow *= candle.l ** w;
+      longClose *= candle.c ** w;
+    }
+    if (missing) continue;
+    for (const token of shortTokens) {
+      const candle = candleLookups[token.symbol]?.get(timestamp);
+      if (!candle) {
+        missing = true;
+        break;
+      }
+      const w = -(token.weight / 100);
+      if (!(candle.o > 0 && candle.h > 0 && candle.l > 0 && candle.c > 0)) {
+        missing = true;
+        break;
+      }
+      shortOpen *= candle.o ** w;
+      shortHigh *= candle.h ** w;
+      shortLow *= candle.l ** w;
+      shortClose *= candle.c ** w;
+    }
+    if (missing) continue;
+    bars.push({
+      time: timestamp,
+      open: longOpen * shortOpen,
+      high: longHigh * shortHigh,
+      low: longLow * shortLow,
+      close: longClose * shortClose
+    });
+  }
+  return bars;
+}
+function computeRealtimeWeightedRatioBar(longTokens, shortTokens, snapshot) {
+  let longOpen = 1;
+  let longHigh = 1;
+  let longLow = 1;
+  let longClose = 1;
+  let shortOpen = 1;
+  let shortHigh = 1;
+  let shortLow = 1;
+  let shortClose = 1;
+  let time = null;
+  for (const token of longTokens) {
+    const c = snapshot[token.symbol];
+    if (!c) return null;
+    if (!(c.o > 0 && c.h > 0 && c.l > 0 && c.c > 0)) return null;
+    const w = token.weight / 100;
+    longOpen *= c.o ** w;
+    longHigh *= c.h ** w;
+    longLow *= c.l ** w;
+    longClose *= c.c ** w;
+    if (time === null) time = c.t;
+  }
+  for (const token of shortTokens) {
+    const c = snapshot[token.symbol];
+    if (!c) return null;
+    if (!(c.o > 0 && c.h > 0 && c.l > 0 && c.c > 0)) return null;
+    const w = -(token.weight / 100);
+    shortOpen *= c.o ** w;
+    shortHigh *= c.h ** w;
+    shortLow *= c.l ** w;
+    shortClose *= c.c ** w;
+    if (time === null) time = c.t;
+  }
+  if (time === null) return null;
+  return {
+    time,
+    open: longOpen * shortOpen,
+    high: longHigh * shortHigh,
+    low: longLow * shortLow,
+    close: longClose * shortClose
+  };
+}
+
+export { computeRealtimeWeightedRatioBar, computeWeightedRatioCandles };

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { Chart } from './chart.js';
+export { Bar, CandleInterval, ChartType, TokenSelection } from './types.js';
+import '@pear-protocol/types';

package/dist/index.js

@@ -0,0 +1 @@
+export { Chart } from './chart';

package/dist/types.d.ts

@@ -0,0 +1,60 @@
+import { Connector } from '@pear-protocol/types';
+
+interface TokenSelection {
+    symbol: string;
+    weight: number;
+}
+type CandleInterval = '1m' | '3m' | '5m' | '15m' | '30m' | '1h' | '2h' | '4h' | '8h' | '12h' | '1d' | '3d' | '1w' | '1M';
+interface CandleData {
+    s?: string;
+    t: number;
+    T: number;
+    o: number;
+    c: number;
+    h: number;
+    l: number;
+}
+interface HistoricalRange {
+    start: number;
+    end: number;
+}
+interface TokenHistoricalPriceData {
+    symbol: string;
+    interval: CandleInterval;
+    candles: CandleData[];
+    oldestTime: number | null;
+    latestTime: number | null;
+    requestedRanges: HistoricalRange[];
+    noDataBefore: number | null;
+}
+interface ChartConfig {
+    longTokens?: TokenSelection[];
+    shortTokens?: TokenSelection[];
+    candleInterval?: CandleInterval;
+    connector?: Connector;
+}
+interface RealtimeSubscription {
+    chartType: ChartType;
+    callback: RealtimeBarCallback;
+    rawListenerId: string;
+}
+type RealtimeCandleCallback = (symbol: string, candle: CandleData) => void;
+type ChartType = 'weighted-ratio' | 'price-ratio' | 'performance';
+interface Bar {
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+}
+type RealtimeBarCallback = (bar: Bar) => void;
+interface PerformanceResult {
+    bars: Bar[];
+    baselinePrices: Record<string, number>;
+}
+interface WsMessage {
+    [key: string]: unknown;
+}
+type MessageListener = (data: string) => void;
+
+export type { Bar, CandleData, CandleInterval, ChartConfig, ChartType, HistoricalRange, MessageListener, PerformanceResult, RealtimeBarCallback, RealtimeCandleCallback, RealtimeSubscription, TokenHistoricalPriceData, TokenSelection, WsMessage };

package/dist/types.js

@@ -0,0 +1 @@
+

package/dist/utils.d.ts

@@ -0,0 +1,10 @@
+import { CandleData, CandleInterval, HistoricalRange } from './types.js';
+import '@pear-protocol/types';
+
+declare const createKey: (symbol: string, interval: CandleInterval) => string;
+declare const getIntervalSeconds: (interval: CandleInterval) => number;
+declare const mergeRanges: (ranges: HistoricalRange[], newRange: HistoricalRange) => HistoricalRange[];
+declare const createCandleLookups: (tokenCandles: Record<string, CandleData[]>) => Record<string, Map<number, CandleData>>;
+declare const getCompleteTimestamps: (candleLookups: Record<string, Map<number, CandleData>>, requiredSymbols: string[]) => number[];
+
+export { createCandleLookups, createKey, getCompleteTimestamps, getIntervalSeconds, mergeRanges };

package/dist/utils.js

@@ -0,0 +1,91 @@
+const createKey = (symbol, interval) => `${symbol}-${interval}`;
+const getIntervalSeconds = (interval) => {
+  switch (interval) {
+    case "1m":
+      return 60;
+    case "3m":
+      return 3 * 60;
+    case "5m":
+      return 5 * 60;
+    case "15m":
+      return 15 * 60;
+    case "30m":
+      return 30 * 60;
+    case "1h":
+      return 60 * 60;
+    case "2h":
+      return 2 * 60 * 60;
+    case "4h":
+      return 4 * 60 * 60;
+    case "8h":
+      return 8 * 60 * 60;
+    case "12h":
+      return 12 * 60 * 60;
+    case "1d":
+      return 24 * 60 * 60;
+    case "3d":
+      return 3 * 24 * 60 * 60;
+    case "1w":
+      return 7 * 24 * 60 * 60;
+    case "1M":
+      return 30 * 24 * 60 * 60;
+  }
+};
+const mergeRanges = (ranges, newRange) => {
+  const all = [...ranges, newRange].sort((a, b) => a.start - b.start);
+  const merged = [];
+  for (const r of all) {
+    const last = merged[merged.length - 1];
+    if (merged.length === 0 || !last || r.start > last.end) {
+      merged.push({ start: r.start, end: r.end });
+    } else {
+      last.end = Math.max(last.end, r.end);
+    }
+  }
+  return merged;
+};
+const createCandleLookups = (tokenCandles) => {
+  const lookups = {};
+  for (const [symbol, candles] of Object.entries(tokenCandles)) {
+    const lookup = /* @__PURE__ */ new Map();
+    for (const candle of candles) {
+      lookup.set(candle.t, candle);
+    }
+    lookups[symbol] = lookup;
+  }
+  return lookups;
+};
+const getCompleteTimestamps = (candleLookups, requiredSymbols) => {
+  if (requiredSymbols.length === 0) return [];
+  let baseSymbol;
+  let baseLookup;
+  let baseSize = Infinity;
+  for (const symbol of requiredSymbols) {
+    const lookup = candleLookups[symbol];
+    const size = lookup?.size ?? 0;
+    if (size === 0) return [];
+    if (size < baseSize) {
+      baseSize = size;
+      baseSymbol = symbol;
+      baseLookup = lookup;
+    }
+  }
+  if (!baseLookup || !baseSymbol) return [];
+  const result = [];
+  for (const timestamp of Array.from(baseLookup.keys())) {
+    let ok = true;
+    for (const symbol of requiredSymbols) {
+      if (symbol === baseSymbol) continue;
+      const lookup = candleLookups[symbol];
+      if (!lookup || !lookup.has(timestamp)) {
+        ok = false;
+        break;
+      }
+    }
+    if (ok) result.push(timestamp);
+  }
+  result.sort((a, b) => a - b);
+  return result;
+};
+
+export { createCandleLookups, createKey, getCompleteTimestamps, getIntervalSeconds, mergeRanges };

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

@@ -0,0 +1,26 @@
+import { CandleInterval, WsMessage, CandleData } from '../types.js';
+import { BaseExchangeWs } from './base-exchange.js';
+import '@pear-protocol/types';
+
+type CandleHandler = (symbol: string, candle: CandleData) => void;
+declare abstract class BaseCandleWs {
+    protected exchangeWs: BaseExchangeWs;
+    private onCandle;
+    private messageListenerId;
+    private openListenerId;
+    private subscribedKeys;
+    protected abstract buildSubscribeMessage(symbol: string, interval: CandleInterval): WsMessage;
+    protected abstract buildUnsubscribeMessage(symbol: string, interval: CandleInterval): WsMessage;
+    protected abstract parseMessage(data: string): {
+        symbol: string;
+        candle: CandleData;
+    } | null;
+    constructor(exchangeWs: BaseExchangeWs, onCandle: CandleHandler);
+    start(): void;
+    stop(): void;
+    get connected(): boolean;
+    subscribe(symbol: string, interval: CandleInterval): void;
+    unsubscribe(symbol: string, interval: CandleInterval): void;
+}
+
+export { BaseCandleWs, type CandleHandler };

package/dist/ws/base-candle.js

@@ -0,0 +1,71 @@
+class BaseCandleWs {
+  exchangeWs;
+  onCandle;
+  messageListenerId = null;
+  openListenerId = null;
+  subscribedKeys = /* @__PURE__ */ new Set();
+  constructor(exchangeWs, onCandle) {
+    this.exchangeWs = exchangeWs;
+    this.onCandle = onCandle;
+  }
+  start() {
+    if (this.messageListenerId) return;
+    this.messageListenerId = this.exchangeWs.addMessageListener((data) => {
+      const result = this.parseMessage(data);
+      if (result) {
+        this.onCandle(result.symbol, result.candle);
+      }
+    });
+    this.openListenerId = this.exchangeWs.addOpenListener(() => {
+      for (const key of this.subscribedKeys) {
+        const [symbol, interval] = key.split("::");
+        this.exchangeWs.send(this.buildSubscribeMessage(symbol, interval));
+      }
+    });
+    if (!this.exchangeWs.connected) {
+      this.exchangeWs.connect();
+    }
+    if (this.exchangeWs.connected) {
+      for (const key of this.subscribedKeys) {
+        const [symbol, interval] = key.split("::");
+        this.exchangeWs.send(this.buildSubscribeMessage(symbol, interval));
+      }
+    }
+  }
+  stop() {
+    if (this.messageListenerId) {
+      this.exchangeWs.removeMessageListener(this.messageListenerId);
+      this.messageListenerId = null;
+    }
+    if (this.openListenerId) {
+      this.exchangeWs.removeOpenListener(this.openListenerId);
+      this.openListenerId = null;
+    }
+    for (const key of this.subscribedKeys) {
+      const [symbol, interval] = key.split("::");
+      this.exchangeWs.send(this.buildUnsubscribeMessage(symbol, interval));
+    }
+    this.subscribedKeys.clear();
+  }
+  get connected() {
+    return this.exchangeWs.connected;
+  }
+  subscribe(symbol, interval) {
+    const key = `${symbol}::${interval}`;
+    if (this.subscribedKeys.has(key)) return;
+    this.subscribedKeys.add(key);
+    if (this.exchangeWs.connected) {
+      this.exchangeWs.send(this.buildSubscribeMessage(symbol, interval));
+    }
+  }
+  unsubscribe(symbol, interval) {
+    const key = `${symbol}::${interval}`;
+    if (!this.subscribedKeys.has(key)) return;
+    this.subscribedKeys.delete(key);
+    if (this.exchangeWs.connected) {
+      this.exchangeWs.send(this.buildUnsubscribeMessage(symbol, interval));
+    }
+  }
+}
+
+export { BaseCandleWs };