@pear-protocol/chart-sdk 0.0.1

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

@@ -0,0 +1,28 @@
+import { WsMessage, MessageListener } from '../types.js';
+import '@pear-protocol/types';
+
+declare abstract class BaseExchangeWs {
+    protected ws: WebSocket | null;
+    protected reconnectAttempts: number;
+    protected reconnectTimer: ReturnType<typeof setTimeout> | null;
+    protected pingTimer: ReturnType<typeof setInterval> | null;
+    protected manualClose: boolean;
+    private messageListeners;
+    private openListeners;
+    protected abstract getWsUrl(): string;
+    protected abstract getPingIntervalMs(): number;
+    protected abstract buildPingMessage(): WsMessage | string | null;
+    connect(): void;
+    disconnect(): void;
+    get connected(): boolean;
+    addMessageListener(listener: MessageListener): string;
+    removeMessageListener(id: string): void;
+    send(msg: WsMessage | string): void;
+    addOpenListener(listener: () => void): string;
+    removeOpenListener(id: string): void;
+    private startPing;
+    private stopPing;
+    private scheduleReconnect;
+}
+
+export { BaseExchangeWs };

package/dist/ws/base-exchange.js

@@ -0,0 +1,93 @@
+class BaseExchangeWs {
+  ws = null;
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  pingTimer = null;
+  manualClose = false;
+  messageListeners = /* @__PURE__ */ new Map();
+  openListeners = /* @__PURE__ */ new Map();
+  connect() {
+    if (this.ws && (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING)) {
+      return;
+    }
+    this.manualClose = false;
+    this.ws = new WebSocket(this.getWsUrl());
+    this.ws.onopen = () => {
+      this.reconnectAttempts = 0;
+      this.startPing();
+      for (const listener of this.openListeners.values()) {
+        listener();
+      }
+    };
+    this.ws.onmessage = (event) => {
+      for (const listener of this.messageListeners.values()) {
+        listener(event.data);
+      }
+    };
+    this.ws.onerror = () => {
+    };
+    this.ws.onclose = () => {
+      this.stopPing();
+      if (!this.manualClose) {
+        this.scheduleReconnect();
+      }
+    };
+  }
+  disconnect() {
+    this.manualClose = true;
+    this.stopPing();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  get connected() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+  addMessageListener(listener) {
+    const id = Math.random().toString(36).slice(2);
+    this.messageListeners.set(id, listener);
+    return id;
+  }
+  removeMessageListener(id) {
+    this.messageListeners.delete(id);
+  }
+  send(msg) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(typeof msg === "string" ? msg : JSON.stringify(msg));
+    }
+  }
+  addOpenListener(listener) {
+    const id = Math.random().toString(36).slice(2);
+    this.openListeners.set(id, listener);
+    return id;
+  }
+  removeOpenListener(id) {
+    this.openListeners.delete(id);
+  }
+  startPing() {
+    this.stopPing();
+    const intervalMs = this.getPingIntervalMs();
+    if (intervalMs <= 0) return;
+    const pingMsg = this.buildPingMessage();
+    if (!pingMsg) return;
+    this.pingTimer = setInterval(() => this.send(pingMsg), intervalMs);
+  }
+  stopPing() {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+  }
+  scheduleReconnect() {
+    this.reconnectAttempts += 1;
+    const delay = Math.min(1e3 * 2 ** (this.reconnectAttempts - 1), 3e4);
+    this.reconnectTimer = setTimeout(() => this.connect(), delay);
+  }
+}
+
+export { BaseExchangeWs };

package/dist/ws/binance.d.ts

@@ -0,0 +1,21 @@
+import { CandleInterval, WsMessage, CandleData } from '../types.js';
+import { BaseCandleWs } from './base-candle.js';
+import { BaseExchangeWs } from './base-exchange.js';
+import '@pear-protocol/types';
+
+declare class BinanceExchangeWs extends BaseExchangeWs {
+    protected getWsUrl(): string;
+    protected getPingIntervalMs(): number;
+    protected buildPingMessage(): null;
+}
+declare class BinanceCandleWs extends BaseCandleWs {
+    private idCounter;
+    protected buildSubscribeMessage(symbol: string, interval: CandleInterval): WsMessage;
+    protected buildUnsubscribeMessage(symbol: string, interval: CandleInterval): WsMessage;
+    protected parseMessage(data: string): {
+        symbol: string;
+        candle: CandleData;
+    } | null;
+}
+
+export { BinanceCandleWs, BinanceExchangeWs };

package/dist/ws/binance.js

@@ -0,0 +1,55 @@
+import { BaseCandleWs } from './base-candle';
+import { BaseExchangeWs } from './base-exchange';
+
+const toStreamName = (symbol, interval) => `${symbol.toLowerCase()}@kline_${interval}`;
+class BinanceExchangeWs extends BaseExchangeWs {
+  getWsUrl() {
+    return "wss://fstream.binance.com/ws";
+  }
+  getPingIntervalMs() {
+    return 0;
+  }
+  buildPingMessage() {
+    return null;
+  }
+}
+class BinanceCandleWs extends BaseCandleWs {
+  idCounter = 1;
+  buildSubscribeMessage(symbol, interval) {
+    return {
+      method: "SUBSCRIBE",
+      params: [toStreamName(symbol, interval)],
+      id: this.idCounter++
+    };
+  }
+  buildUnsubscribeMessage(symbol, interval) {
+    return {
+      method: "UNSUBSCRIBE",
+      params: [toStreamName(symbol, interval)],
+      id: this.idCounter++
+    };
+  }
+  parseMessage(data) {
+    let msg;
+    try {
+      msg = JSON.parse(data);
+    } catch {
+      return null;
+    }
+    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)
+      }
+    };
+  }
+}
+
+export { BinanceCandleWs, BinanceExchangeWs };

package/dist/ws/bybit.d.ts

@@ -0,0 +1,20 @@
+import { CandleInterval, WsMessage, CandleData } from '../types.js';
+import { BaseCandleWs } from './base-candle.js';
+import { BaseExchangeWs } from './base-exchange.js';
+import '@pear-protocol/types';
+
+declare class BybitExchangeWs extends BaseExchangeWs {
+    protected getWsUrl(): string;
+    protected getPingIntervalMs(): number;
+    protected buildPingMessage(): WsMessage;
+}
+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;
+}
+
+export { BybitCandleWs, BybitExchangeWs };

package/dist/ws/bybit.js

@@ -0,0 +1,75 @@
+import { BaseCandleWs } from './base-candle';
+import { BaseExchangeWs } from './base-exchange';
+
+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"
+};
+const toTopic = (symbol, interval) => `kline.${intervalMap[interval]}.${symbol}`;
+const fromTopic = (topic) => {
+  const parts = topic.split(".");
+  return parts[2] ?? "";
+};
+class BybitExchangeWs extends BaseExchangeWs {
+  getWsUrl() {
+    return "wss://stream.bybit.com/v5/public/linear";
+  }
+  getPingIntervalMs() {
+    return 2e4;
+  }
+  buildPingMessage() {
+    return { op: "ping" };
+  }
+}
+class BybitCandleWs extends BaseCandleWs {
+  buildSubscribeMessage(symbol, interval) {
+    return {
+      op: "subscribe",
+      args: [toTopic(symbol, interval)]
+    };
+  }
+  buildUnsubscribeMessage(symbol, interval) {
+    return {
+      op: "unsubscribe",
+      args: [toTopic(symbol, interval)]
+    };
+  }
+  parseMessage(data) {
+    let msg;
+    try {
+      msg = JSON.parse(data);
+    } catch {
+      return null;
+    }
+    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)
+      }
+    };
+  }
+}
+
+export { BybitCandleWs, BybitExchangeWs };

package/dist/ws/hyperliquid.d.ts

@@ -0,0 +1,33 @@
+import { CandleInterval, WsMessage, CandleData } from '../types.js';
+import { BaseCandleWs } from './base-candle.js';
+import { BaseExchangeWs } from './base-exchange.js';
+import '@pear-protocol/types';
+
+interface HyperliquidCandleSubscription {
+    type: 'candle';
+    coin: string;
+    interval: CandleInterval;
+}
+interface HyperliquidSubscribeMessage extends WsMessage {
+    method: 'subscribe';
+    subscription: HyperliquidCandleSubscription;
+}
+interface HyperliquidUnsubscribeMessage extends WsMessage {
+    method: 'unsubscribe';
+    subscription: HyperliquidCandleSubscription;
+}
+declare class HyperliquidExchangeWs extends BaseExchangeWs {
+    protected getWsUrl(): string;
+    protected getPingIntervalMs(): number;
+    protected buildPingMessage(): 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;
+}
+
+export { HyperliquidCandleWs, HyperliquidExchangeWs };

package/dist/ws/hyperliquid.js

@@ -0,0 +1,52 @@
+import { BaseCandleWs } from './base-candle';
+import { BaseExchangeWs } from './base-exchange';
+
+class HyperliquidExchangeWs extends BaseExchangeWs {
+  getWsUrl() {
+    return "wss://api.hyperliquid.xyz/ws";
+  }
+  getPingIntervalMs() {
+    return 3e4;
+  }
+  buildPingMessage() {
+    return { method: "ping" };
+  }
+}
+class HyperliquidCandleWs extends BaseCandleWs {
+  buildSubscribeMessage(symbol, interval) {
+    return {
+      method: "subscribe",
+      subscription: { type: "candle", coin: symbol, interval }
+    };
+  }
+  buildUnsubscribeMessage(symbol, interval) {
+    return {
+      method: "unsubscribe",
+      subscription: { type: "candle", coin: symbol, interval }
+    };
+  }
+  parseMessage(data) {
+    let msg;
+    try {
+      msg = JSON.parse(data);
+    } catch {
+      return null;
+    }
+    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)
+      }
+    };
+  }
+}
+
+export { HyperliquidCandleWs, HyperliquidExchangeWs };

package/dist/ws/index.d.ts

@@ -0,0 +1,12 @@
+import { Connector } from '@pear-protocol/types';
+import { BaseCandleWs, CandleHandler } from './base-candle.js';
+import { BaseExchangeWs } from './base-exchange.js';
+import '../types.js';
+
+interface CandleWsBundle {
+    exchangeWs: BaseExchangeWs;
+    candleWs: BaseCandleWs;
+}
+declare function createCandleWs(connector: Connector, onCandle: CandleHandler): CandleWsBundle;
+
+export { BaseCandleWs, BaseExchangeWs, CandleHandler, type CandleWsBundle, createCandleWs };

package/dist/ws/index.js

@@ -0,0 +1,42 @@
+export { BaseCandleWs } from './base-candle';
+export { BaseExchangeWs } from './base-exchange';
+import { BinanceExchangeWs, BinanceCandleWs } from './binance';
+import { BybitExchangeWs, BybitCandleWs } from './bybit';
+import { HyperliquidExchangeWs, HyperliquidCandleWs } from './hyperliquid';
+import { OkxExchangeWs, OkxCandleWs } from './okx';
+
+function createExchangeWs(connector) {
+  switch (connector) {
+    case "hyperliquid":
+      return new HyperliquidExchangeWs();
+    case "binanceusdm":
+      return new BinanceExchangeWs();
+    case "bybit":
+      return new BybitExchangeWs();
+    case "okx":
+      return new OkxExchangeWs();
+    default:
+      throw new Error(`Unsupported exchange: ${connector}`);
+  }
+}
+function createCandleWsForExchange(connector, exchangeWs, onCandle) {
+  switch (connector) {
+    case "hyperliquid":
+      return new HyperliquidCandleWs(exchangeWs, onCandle);
+    case "binanceusdm":
+      return new BinanceCandleWs(exchangeWs, onCandle);
+    case "bybit":
+      return new BybitCandleWs(exchangeWs, onCandle);
+    case "okx":
+      return new OkxCandleWs(exchangeWs, onCandle);
+    default:
+      throw new Error(`Unsupported exchange: ${connector}`);
+  }
+}
+function createCandleWs(connector, onCandle) {
+  const exchangeWs = createExchangeWs(connector);
+  const candleWs = createCandleWsForExchange(connector, exchangeWs, onCandle);
+  return { exchangeWs, candleWs };
+}
+
+export { createCandleWs };

package/dist/ws/okx.d.ts

@@ -0,0 +1,20 @@
+import { CandleInterval, WsMessage, CandleData } from '../types.js';
+import { BaseCandleWs } from './base-candle.js';
+import { BaseExchangeWs } from './base-exchange.js';
+import '@pear-protocol/types';
+
+declare class OkxExchangeWs extends BaseExchangeWs {
+    protected getWsUrl(): string;
+    protected getPingIntervalMs(): number;
+    protected buildPingMessage(): string;
+}
+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;
+}
+
+export { OkxCandleWs, OkxExchangeWs };

package/dist/ws/okx.js

@@ -0,0 +1,72 @@
+import { BaseCandleWs } from './base-candle';
+import { BaseExchangeWs } from './base-exchange';
+
+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"
+};
+const toChannel = (interval) => `candle${intervalMap[interval]}`;
+class OkxExchangeWs extends BaseExchangeWs {
+  getWsUrl() {
+    return "wss://ws.okx.com:8443/ws/v5/public";
+  }
+  getPingIntervalMs() {
+    return 25e3;
+  }
+  buildPingMessage() {
+    return "ping";
+  }
+}
+class OkxCandleWs extends BaseCandleWs {
+  buildSubscribeMessage(symbol, interval) {
+    return {
+      op: "subscribe",
+      args: [{ channel: toChannel(interval), instId: symbol }]
+    };
+  }
+  buildUnsubscribeMessage(symbol, interval) {
+    return {
+      op: "unsubscribe",
+      args: [{ channel: toChannel(interval), instId: symbol }]
+    };
+  }
+  parseMessage(data) {
+    if (data === "pong") return null;
+    let msg;
+    try {
+      msg = JSON.parse(data);
+    } catch {
+      return null;
+    }
+    const arg = msg.arg;
+    const candleData = msg.data;
+    if (!arg || !candleData || !Array.isArray(candleData) || candleData.length === 0) return null;
+    if (!arg.channel.startsWith("candle")) return null;
+    const d = candleData[0];
+    return {
+      symbol: arg.instId,
+      candle: {
+        t: Number(d[0]),
+        T: Number(d[0]),
+        o: Number(d[1]),
+        h: Number(d[2]),
+        l: Number(d[3]),
+        c: Number(d[4])
+      }
+    };
+  }
+}
+
+export { OkxCandleWs, OkxExchangeWs };

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@pear-protocol/chart-sdk",
+  "version": "0.0.1",
+  "description": "Pear Protocol Chart SDK",
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsup",
+    "clean": "rm -rf dist .turbo",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@pear-protocol/types": "0.0.3"
+  },
+  "devDependencies": {
+    "@backend/typescript-config": "workspace:*",
+    "tsup": "8.5.1",
+    "typescript": "5.9.3"
+  }
+}