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

package/dist/chart/collector/helpers.d.ts

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

package/dist/chart/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 "binance":
+      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/chart/collector/hyperliquid.d.ts

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

package/dist/chart/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/chart/collector/index.d.ts

@@ -0,0 +1,41 @@
+import { ChartConfig, TokenSelection, CandleInterval, RealtimeCandleCallback, CandleData } from '../types.js';
+import '../../transport/index.js';
+import '@pear-protocol/types';
+import '../../transport/base-transport.js';
+import 'partysocket';
+import '../../shared/types.js';
+
+declare class DataCollector {
+    private transport;
+    private longTokens;
+    private shortTokens;
+    private candleInterval;
+    private prevTokenSymbols;
+    private prevInterval;
+    private candleWs;
+    private latestCandles;
+    private realtimeListeners;
+    private cache;
+    constructor(config: ChartConfig);
+    setTokens(longTokens: TokenSelection[], shortTokens: TokenSelection[]): void;
+    setCandleInterval(interval: CandleInterval): void;
+    attachCandleWs(): void;
+    detachCandleWs(): void;
+    get isWsAttached(): boolean;
+    addRealtimeListener(id: string, cb: RealtimeCandleCallback): void;
+    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/chart/collector/index.js

@@ -0,0 +1,202 @@
+import { CandleCache } from '../cache';
+import { createCandleWs } from '../ws';
+import { fetchHistoricalCandles } from './helpers';
+
+class DataCollector {
+  transport;
+  longTokens;
+  shortTokens;
+  candleInterval;
+  prevTokenSymbols = /* @__PURE__ */ new Set();
+  prevInterval = null;
+  candleWs = null;
+  latestCandles = /* @__PURE__ */ new Map();
+  realtimeListeners = /* @__PURE__ */ new Map();
+  cache = new CandleCache();
+  constructor(config) {
+    this.transport = config.transport;
+    this.longTokens = config.longTokens ?? [];
+    this.shortTokens = config.shortTokens ?? [];
+    this.candleInterval = config.candleInterval ?? "1h";
+    this.syncTokenChanges();
+  }
+  setTokens(longTokens, shortTokens) {
+    this.longTokens = longTokens;
+    this.shortTokens = shortTokens;
+    this.syncWsSubscriptions();
+    this.syncTokenChanges();
+  }
+  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);
+      }
+    }
+  }
+  attachCandleWs() {
+    if (this.candleWs) return;
+    this.candleWs = createCandleWs(this.transport, this.transport.connector, (symbol, candle) => {
+      this.latestCandles.set(symbol, candle);
+      for (const cb of this.realtimeListeners.values()) {
+        try {
+          cb(symbol, candle);
+        } catch (error) {
+          console.warn("Error in realtime listener callback", error);
+        }
+      }
+    });
+    this.candleWs.start();
+    for (const token of this.getAllTokens()) {
+      this.candleWs.subscribe(token.symbol, this.candleInterval);
+    }
+  }
+  detachCandleWs() {
+    if (this.candleWs) {
+      this.candleWs.stop();
+      this.candleWs = null;
+    }
+  }
+  get isWsAttached() {
+    return this.candleWs !== null;
+  }
+  addRealtimeListener(id, cb) {
+    this.realtimeListeners.set(id, cb);
+  }
+  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.transport.connector,
+            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.detachCandleWs();
+    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.prevTokenSymbols) {
+      if (!currentSymbols.has(symbol)) {
+        this.candleWs.unsubscribe(symbol, this.candleInterval);
+        this.latestCandles.delete(symbol);
+      }
+    }
+    if (currentSymbols.size === 0) {
+      this.detachCandleWs();
+      this.latestCandles.clear();
+      return;
+    }
+    for (const symbol of currentSymbols) {
+      this.candleWs.subscribe(symbol, this.candleInterval);
+    }
+  }
+}
+
+export { DataCollector };

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

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

package/dist/chart/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/chart/compute/asset.d.ts

@@ -0,0 +1,11 @@
+import { CandleData, Bar } from '../types.js';
+import '../../transport/index.js';
+import '@pear-protocol/types';
+import '../../transport/base-transport.js';
+import 'partysocket';
+import '../../shared/types.js';
+
+declare function computeAssetBars(tokenCandles: Record<string, CandleData[]>, symbol: string): Bar[];
+declare function computeRealtimeAssetBar(snapshot: Record<string, CandleData>, symbol: string): Bar | null;
+
+export { computeAssetBars, computeRealtimeAssetBar };

package/dist/chart/compute/asset.js

@@ -0,0 +1,24 @@
+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
+  }));
+}
+function computeRealtimeAssetBar(snapshot, symbol) {
+  const candle = snapshot[symbol];
+  if (!candle) return null;
+  return {
+    time: candle.t,
+    open: candle.o,
+    high: candle.h,
+    low: candle.l,
+    close: candle.c
+  };
+}
+
+export { computeAssetBars, computeRealtimeAssetBar };

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

@@ -0,0 +1,10 @@
+export { computeAssetBars, computeRealtimeAssetBar } 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 '../../transport/index.js';
+import '@pear-protocol/types';
+import '../../transport/base-transport.js';
+import 'partysocket';
+import '../../shared/types.js';

package/dist/chart/compute/index.js

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

package/dist/chart/compute/performance.d.ts

@@ -0,0 +1,11 @@
+import { TokenSelection, CandleData, PerformanceResult, Bar } from '../types.js';
+import '../../transport/index.js';
+import '@pear-protocol/types';
+import '../../transport/base-transport.js';
+import 'partysocket';
+import '../../shared/types.js';
+
+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/chart/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/chart/compute/price-ratio.d.ts

@@ -0,0 +1,11 @@
+import { TokenSelection, CandleData, Bar } from '../types.js';
+import '../../transport/index.js';
+import '@pear-protocol/types';
+import '../../transport/base-transport.js';
+import 'partysocket';
+import '../../shared/types.js';
+
+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/chart/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 += w * candle.o;
+      longSumH += w * candle.h;
+      longSumL += w * candle.l;
+      longSumC += w * candle.c;
+    }
+    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 += w * candle.o;
+      shortSumH += w * candle.h;
+      shortSumL += w * candle.l;
+      shortSumC += w * candle.c;
+    }
+    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 += w * c.o;
+    longSumH += w * c.h;
+    longSumL += w * c.l;
+    longSumC += w * c.c;
+    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 += w * c.o;
+    shortSumH += w * c.h;
+    shortSumL += w * c.l;
+    shortSumC += w * c.c;
+    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/chart/compute/weighted-ratio.d.ts

@@ -0,0 +1,11 @@
+import { TokenSelection, CandleData, Bar } from '../types.js';
+import '../../transport/index.js';
+import '@pear-protocol/types';
+import '../../transport/base-transport.js';
+import 'partysocket';
+import '../../shared/types.js';
+
+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 };