@pear-protocol/market-sdk 0.0.1-preview.0

package/dist/chart/compute/weighted-ratio.js

@@ -0,0 +1,109 @@
+import { createCandleLookups, getCompleteTimestamps } from '../utils';
+
+function pow(base, exponent) {
+  if (base <= 0) return 0;
+  return Math.exp(exponent * Math.log(base));
+}
+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 *= pow(candle.o, w);
+      longHigh *= pow(candle.h, w);
+      longLow *= pow(candle.l, w);
+      longClose *= pow(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 *= pow(candle.o, w);
+      shortHigh *= pow(candle.h, w);
+      shortLow *= pow(candle.l, w);
+      shortClose *= pow(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 *= pow(c.o, w);
+    longHigh *= pow(c.h, w);
+    longLow *= pow(c.l, w);
+    longClose *= pow(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 *= pow(c.o, w);
+    shortHigh *= pow(c.h, w);
+    shortLow *= pow(c.l, w);
+    shortClose *= pow(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/chart/types.d.ts

@@ -0,0 +1,55 @@
+import { Transport } from '../transport/index.js';
+import '@pear-protocol/types';
+import '../transport/base-transport.js';
+import 'partysocket';
+import '../shared/types.js';
+
+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 {
+    transport: Transport;
+    longTokens?: TokenSelection[];
+    shortTokens?: TokenSelection[];
+    candleInterval?: CandleInterval;
+}
+type RealtimeCandleCallback = (symbol: string, candle: CandleData) => void;
+type ChartType = 'weighted-ratio' | 'price-ratio' | 'performance' | 'price';
+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>;
+}
+
+export type { Bar, CandleData, CandleInterval, ChartConfig, ChartType, HistoricalRange, PerformanceResult, RealtimeBarCallback, RealtimeCandleCallback, TokenHistoricalPriceData, TokenSelection };

package/dist/chart/types.js

@@ -0,0 +1 @@
+

package/dist/chart/utils.d.ts

@@ -0,0 +1,14 @@
+import { CandleData, CandleInterval, HistoricalRange } from './types.js';
+import '../transport/index.js';
+import '@pear-protocol/types';
+import '../transport/base-transport.js';
+import 'partysocket';
+import '../shared/types.js';
+
+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/chart/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/chart/ws/base-candle.d.ts

@@ -0,0 +1,29 @@
+import { WsMessage } from '../../shared/types.js';
+import { BaseTransport } from '../../transport/base-transport.js';
+import { CandleInterval, CandleData } from '../types.js';
+import '@pear-protocol/types';
+import 'partysocket';
+import '../../transport/index.js';
+
+type CandleHandler = (symbol: string, candle: CandleData) => void;
+declare abstract class BaseCandleWs {
+    protected transport: BaseTransport;
+    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(transport: BaseTransport, 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/chart/ws/base-candle.js

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

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

@@ -0,0 +1,19 @@
+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 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 };

package/dist/chart/ws/binance.js

@@ -0,0 +1,43 @@
+import { BaseCandleWs } from './base-candle';
+
+const toStreamName = (symbol, interval) => `${symbol.toLowerCase()}@kline_${interval}`;
+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 };

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

@@ -0,0 +1,18 @@
+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 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 };

package/dist/chart/ws/bybit.js

@@ -0,0 +1,63 @@
+import { BaseCandleWs } from './base-candle';
+
+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 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 };

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

@@ -0,0 +1,31 @@
+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';
+
+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 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 };

package/dist/chart/ws/hyperliquid.js

@@ -0,0 +1,40 @@
+import { BaseCandleWs } from './base-candle';
+
+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 };

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

@@ -0,0 +1,11 @@
+import { Connector } from '@pear-protocol/types';
+import { BaseTransport } from '../../transport/base-transport.js';
+import { CandleHandler, BaseCandleWs } from './base-candle.js';
+import 'partysocket';
+import '../../shared/types.js';
+import '../types.js';
+import '../../transport/index.js';
+
+declare function createCandleWs(transport: BaseTransport, connector: Connector, onCandle: CandleHandler): BaseCandleWs;
+
+export { BaseCandleWs, CandleHandler, createCandleWs };

package/dist/chart/ws/index.js

@@ -0,0 +1,24 @@
+export { BaseCandleWs } from './base-candle';
+import { BinanceCandleWs } from './binance';
+import { BybitCandleWs } from './bybit';
+import { HyperliquidCandleWs } from './hyperliquid';
+import { OkxCandleWs } from './okx';
+
+function createCandleWs(transport, connector, onCandle) {
+  switch (connector) {
+    case "hyperliquid":
+      return new HyperliquidCandleWs(transport, onCandle);
+    case "binance":
+      return new BinanceCandleWs(transport, onCandle);
+    case "bybit":
+      return new BybitCandleWs(transport, onCandle);
+    case "okx":
+      return new OkxCandleWs(transport, onCandle);
+    default: {
+      const _exhaustive = connector;
+      throw new Error(`Unsupported exchange: ${String(_exhaustive)}`);
+    }
+  }
+}
+
+export { createCandleWs };

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

@@ -0,0 +1,18 @@
+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 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 };