@pear-protocol/market-sdk 0.0.13 → 0.1.0

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

@@ -1,9 +1,14 @@
 import { createCandleLookups, getCompleteTimestamps } from '../utils';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 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 allSymbols = [
+    ...longTokens,
+    ...shortTokens
+  ].map((t) => t.symbol);
   const completeTimestamps = getCompleteTimestamps(candleLookups, allSymbols);
   const bars = [];
   for (const timestamp of completeTimestamps) {
@@ -61,6 +66,7 @@ function computePriceRatioCandles(longTokens, shortTokens, tokenCandles) {
   }
   return bars;
 }
+__name(computePriceRatioCandles, "computePriceRatioCandles");
 function computeRealtimePriceRatioBar(longTokens, shortTokens, snapshot) {
   let longSumO = 0;
   let longSumH = 0;
@@ -103,5 +109,6 @@ function computeRealtimePriceRatioBar(longTokens, shortTokens, snapshot) {
     close: longSumC / shortSumC
   };
 }
+__name(computeRealtimePriceRatioBar, "computeRealtimePriceRatioBar");
 
 export { computePriceRatioCandles, computeRealtimePriceRatioBar };

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

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

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

@@ -1,13 +1,19 @@
 import { createCandleLookups, getCompleteTimestamps } from '../utils';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 function pow(base, exponent) {
   if (base <= 0) return 0;
   return Math.exp(exponent * Math.log(base));
 }
+__name(pow, "pow");
 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 allSymbols = [
+    ...longTokens,
+    ...shortTokens
+  ].map((t) => t.symbol);
   const completeTimestamps = getCompleteTimestamps(candleLookups, allSymbols);
   const bars = [];
   for (const timestamp of completeTimestamps) {
@@ -64,6 +70,7 @@ function computeWeightedRatioCandles(longTokens, shortTokens, tokenCandles) {
   }
   return bars;
 }
+__name(computeWeightedRatioCandles, "computeWeightedRatioCandles");
 function computeRealtimeWeightedRatioBar(longTokens, shortTokens, snapshot) {
   let longOpen = 1;
   let longHigh = 1;
@@ -105,5 +112,6 @@ function computeRealtimeWeightedRatioBar(longTokens, shortTokens, snapshot) {
     close: longClose * shortClose
   };
 }
+__name(computeRealtimeWeightedRatioBar, "computeRealtimeWeightedRatioBar");
 
 export { computeRealtimeWeightedRatioBar, computeWeightedRatioCandles };

package/dist/chart/types.d.ts

@@ -1,8 +1,8 @@
 import { Transport } from '../transport/index.js';
 import '@pear-protocol/types';
+import '../shared/types.js';
 import '../transport/base-transport.js';
 import 'partysocket';
-import '../shared/types.js';
 
 interface TokenSelection {
     symbol: string;

package/dist/chart/utils.d.ts

@@ -1,9 +1,9 @@
 import { CandleData, CandleInterval, HistoricalRange } from './types.js';
 import '../transport/index.js';
 import '@pear-protocol/types';
+import '../shared/types.js';
 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;

package/dist/chart/utils.js

@@ -1,5 +1,7 @@
-const createKey = (symbol, interval) => `${symbol}-${interval}`;
-const getIntervalSeconds = (interval) => {
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const createKey = /* @__PURE__ */ __name((symbol, interval) => `${symbol}-${interval}`, "createKey");
+const getIntervalSeconds = /* @__PURE__ */ __name((interval) => {
   switch (interval) {
     case "1m":
       return 60;
@@ -30,21 +32,27 @@ const getIntervalSeconds = (interval) => {
     case "1M":
       return 30 * 24 * 60 * 60;
   }
-};
-const mergeRanges = (ranges, newRange) => {
-  const all = [...ranges, newRange].sort((a, b) => a.start - b.start);
+}, "getIntervalSeconds");
+const mergeRanges = /* @__PURE__ */ __name((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 });
+      merged.push({
+        start: r.start,
+        end: r.end
+      });
     } else {
       last.end = Math.max(last.end, r.end);
     }
   }
   return merged;
-};
-const createCandleLookups = (tokenCandles) => {
+}, "mergeRanges");
+const createCandleLookups = /* @__PURE__ */ __name((tokenCandles) => {
   const lookups = {};
   for (const [symbol, candles] of Object.entries(tokenCandles)) {
     const lookup = /* @__PURE__ */ new Map();
@@ -54,8 +62,8 @@ const createCandleLookups = (tokenCandles) => {
     lookups[symbol] = lookup;
   }
   return lookups;
-};
-const getCompleteTimestamps = (candleLookups, requiredSymbols) => {
+}, "createCandleLookups");
+const getCompleteTimestamps = /* @__PURE__ */ __name((candleLookups, requiredSymbols) => {
   if (requiredSymbols.length === 0) return [];
   let baseSymbol;
   let baseLookup;
@@ -86,6 +94,6 @@ const getCompleteTimestamps = (candleLookups, requiredSymbols) => {
   }
   result.sort((a, b) => a - b);
   return result;
-};
+}, "getCompleteTimestamps");
 
 export { createCandleLookups, createKey, getCompleteTimestamps, getIntervalSeconds, mergeRanges };

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

@@ -6,6 +6,10 @@ import 'partysocket';
 import '../../transport/index.js';
 
 type CandleHandler = (symbol: string, candle: CandleData) => void;
+type ParsedCandle = {
+    symbol: string;
+    candle: CandleData;
+};
 declare abstract class BaseCandleWs {
     protected transport: BaseTransport;
     protected onCandle: CandleHandler;
@@ -14,10 +18,12 @@ declare abstract class BaseCandleWs {
     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;
+    /**
+     * One venue message can carry several candles: on rollover Lighter sends the just-closed period
+     * alongside the freshly opened one, and dropping the closed one would leave that bar missing its
+     * final trades. Venues that only ever send one candle return a single-element array.
+     */
+    protected abstract parseMessages(data: string): ParsedCandle[];
     constructor(transport: BaseTransport, onCandle: CandleHandler);
     start(): void;
     stop(): void;
@@ -27,4 +33,4 @@ declare abstract class BaseCandleWs {
     unsubscribe(symbol: string, interval: CandleInterval): void;
 }
 
-export { BaseCandleWs, type CandleHandler };
+export { BaseCandleWs, type CandleHandler, type ParsedCandle };

package/dist/chart/ws/base-candle.js

@@ -1,4 +1,9 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 class BaseCandleWs {
+  static {
+    __name(this, "BaseCandleWs");
+  }
   transport;
   onCandle;
   messageListenerId = null;
@@ -11,8 +16,7 @@ class BaseCandleWs {
   start() {
     if (this.messageListenerId) return;
     this.messageListenerId = this.transport.addMessageListener((data) => {
-      const result = this.parseMessage(data);
-      if (result) {
+      for (const result of this.parseMessages(data)) {
         this.onCandle(result.symbol, result.candle);
       }
     });

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

@@ -1,6 +1,6 @@
 import { WsMessage } from '../../shared/types.js';
-import { CandleInterval, CandleData } from '../types.js';
-import { BaseCandleWs } from './base-candle.js';
+import { CandleInterval } from '../types.js';
+import { BaseCandleWs, ParsedCandle } from './base-candle.js';
 import '../../transport/index.js';
 import '@pear-protocol/types';
 import '../../transport/base-transport.js';
@@ -10,10 +10,8 @@ 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;
+    /** Translates one Binance kline frame into a single-candle batch. */
+    protected parseMessages(data: string): ParsedCandle[];
 }
 
 export { BinanceCandleWs };

package/dist/chart/ws/binance.js

@@ -1,42 +1,56 @@
 import { BaseCandleWs } from './base-candle';
 
-const toStreamName = (symbol, interval) => `${symbol.toLowerCase()}@kline_${interval}`;
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const toStreamName = /* @__PURE__ */ __name((symbol, interval) => `${symbol.toLowerCase()}@kline_${interval}`, "toStreamName");
 class BinanceCandleWs extends BaseCandleWs {
+  static {
+    __name(this, "BinanceCandleWs");
+  }
   idCounter = 1;
   buildSubscribeMessage(symbol, interval) {
     return {
       method: "SUBSCRIBE",
-      params: [toStreamName(symbol, interval)],
+      params: [
+        toStreamName(symbol, interval)
+      ],
       id: this.idCounter++
     };
   }
   buildUnsubscribeMessage(symbol, interval) {
     return {
       method: "UNSUBSCRIBE",
-      params: [toStreamName(symbol, interval)],
+      params: [
+        toStreamName(symbol, interval)
+      ],
       id: this.idCounter++
     };
   }
-  parseMessage(data) {
-    let msg;
+  /** Translates one Binance kline frame into a single-candle batch. */
+  parseMessages(data) {
+    let message;
     try {
-      msg = JSON.parse(data);
+      message = JSON.parse(data);
     } catch {
-      return null;
+      return [];
     }
-    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)
+    if (message.e !== "kline" || !message.k) {
+      return [];
+    }
+    const kline = message.k;
+    return [
+      {
+        symbol: kline.s,
+        candle: {
+          t: kline.t,
+          T: kline.T,
+          o: Number(kline.o),
+          h: Number(kline.h),
+          l: Number(kline.l),
+          c: Number(kline.c)
+        }
       }
-    };
+    ];
   }
 }
 

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

@@ -1,6 +1,6 @@
 import { WsMessage } from '../../shared/types.js';
-import { CandleInterval, CandleData } from '../types.js';
-import { BaseCandleWs } from './base-candle.js';
+import { CandleInterval } from '../types.js';
+import { BaseCandleWs, ParsedCandle } from './base-candle.js';
 import '../../transport/index.js';
 import '@pear-protocol/types';
 import '../../transport/base-transport.js';
@@ -9,10 +9,8 @@ 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;
+    /** Translates one Bybit kline frame into a single-candle batch. */
+    protected parseMessages(data: string): ParsedCandle[];
 }
 
 export { BybitCandleWs };

package/dist/chart/ws/bybit.js

@@ -1,5 +1,7 @@
 import { BaseCandleWs } from './base-candle';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 const intervalMap = {
   "1m": "1",
   "3m": "3",
@@ -16,47 +18,61 @@ const intervalMap = {
   "1w": "W",
   "1M": "M"
 };
-const toTopic = (symbol, interval) => `kline.${intervalMap[interval]}.${symbol}`;
-const fromTopic = (topic) => {
+const toTopic = /* @__PURE__ */ __name((symbol, interval) => `kline.${intervalMap[interval]}.${symbol}`, "toTopic");
+const fromTopic = /* @__PURE__ */ __name((topic) => {
   const parts = topic.split(".");
   return parts[2] ?? "";
-};
+}, "fromTopic");
 class BybitCandleWs extends BaseCandleWs {
+  static {
+    __name(this, "BybitCandleWs");
+  }
   buildSubscribeMessage(symbol, interval) {
     return {
       op: "subscribe",
-      args: [toTopic(symbol, interval)]
+      args: [
+        toTopic(symbol, interval)
+      ]
     };
   }
   buildUnsubscribeMessage(symbol, interval) {
     return {
       op: "unsubscribe",
-      args: [toTopic(symbol, interval)]
+      args: [
+        toTopic(symbol, interval)
+      ]
     };
   }
-  parseMessage(data) {
-    let msg;
+  /** Translates one Bybit kline frame into a single-candle batch. */
+  parseMessages(data) {
+    let message;
     try {
-      msg = JSON.parse(data);
+      message = JSON.parse(data);
     } catch {
-      return null;
+      return [];
     }
-    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)
+    const topic = message.topic;
+    const klines = message.data;
+    if (!topic || !klines || !Array.isArray(klines) || klines.length === 0) {
+      return [];
+    }
+    if (!topic.startsWith("kline.")) {
+      return [];
+    }
+    const kline = klines[0];
+    return [
+      {
+        symbol: fromTopic(topic),
+        candle: {
+          t: kline.start,
+          T: kline.end,
+          o: Number(kline.open),
+          h: Number(kline.high),
+          l: Number(kline.low),
+          c: Number(kline.close)
+        }
       }
-    };
+    ];
   }
 }
 

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

@@ -1,6 +1,6 @@
 import { WsMessage } from '../../shared/types.js';
-import { CandleInterval, CandleData } from '../types.js';
-import { BaseCandleWs } from './base-candle.js';
+import { CandleInterval } from '../types.js';
+import { BaseCandleWs, ParsedCandle } from './base-candle.js';
 import '../../transport/index.js';
 import '@pear-protocol/types';
 import '../../transport/base-transport.js';
@@ -22,10 +22,8 @@ interface HyperliquidUnsubscribeMessage extends 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;
+    /** Translates one Hyperliquid candle frame into a single-candle batch. */
+    protected parseMessages(data: string): ParsedCandle[];
 }
 
 export { HyperliquidCandleWs };

package/dist/chart/ws/hyperliquid.js

@@ -1,39 +1,57 @@
 import { BaseCandleWs } from './base-candle';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 class HyperliquidCandleWs extends BaseCandleWs {
+  static {
+    __name(this, "HyperliquidCandleWs");
+  }
   buildSubscribeMessage(symbol, interval) {
     return {
       method: "subscribe",
-      subscription: { type: "candle", coin: symbol, interval }
+      subscription: {
+        type: "candle",
+        coin: symbol,
+        interval
+      }
     };
   }
   buildUnsubscribeMessage(symbol, interval) {
     return {
       method: "unsubscribe",
-      subscription: { type: "candle", coin: symbol, interval }
+      subscription: {
+        type: "candle",
+        coin: symbol,
+        interval
+      }
     };
   }
-  parseMessage(data) {
-    let msg;
+  /** Translates one Hyperliquid candle frame into a single-candle batch. */
+  parseMessages(data) {
+    let message;
     try {
-      msg = JSON.parse(data);
+      message = JSON.parse(data);
     } catch {
-      return null;
+      return [];
     }
-    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)
+    if (message.channel !== "candle" || !message.data) {
+      return [];
+    }
+    const payload = message.data;
+    return [
+      {
+        symbol: payload.s,
+        candle: {
+          s: payload.s,
+          t: payload.t,
+          T: payload.T,
+          o: Number(payload.o),
+          h: Number(payload.h),
+          l: Number(payload.l),
+          c: Number(payload.c)
+        }
       }
-    };
+    ];
   }
 }
 

package/dist/chart/ws/index.js

@@ -5,6 +5,8 @@ import { HyperliquidCandleWs } from './hyperliquid';
 import { LighterCandleWs } from './lighter';
 import { OkxCandleWs } from './okx';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 function createCandleWs(transport, connector, onCandle) {
   switch (connector) {
     case "hyperliquid":
@@ -23,5 +25,6 @@ function createCandleWs(transport, connector, onCandle) {
     }
   }
 }
+__name(createCandleWs, "createCandleWs");
 
 export { createCandleWs };

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

@@ -1,30 +1,30 @@
 import { WsMessage } from '../../shared/types.js';
-import { CandleInterval, CandleData } from '../types.js';
-import { BaseCandleWs } from './base-candle.js';
+import { CandleInterval } from '../types.js';
+import { BaseCandleWs, ParsedCandle } from './base-candle.js';
 import '../../transport/index.js';
 import '@pear-protocol/types';
 import '../../transport/base-transport.js';
 import 'partysocket';
 
+/**
+ * Lighter publishes ready-made OHLC candles on a dedicated channel, so this class only translates
+ * them onto CandleData — it never aggregates the trade tape and never seeds itself over REST, because
+ * the subscribe acknowledgement already carries the current live candle.
+ * Docs: https://apidocs.lighter.xyz/docs/websocket-reference#candlesticks
+ */
+
 declare class LighterCandleWs extends BaseCandleWs {
-    private symbolIntervals;
-    private candleState;
-    private ownMessageListenerId;
-    private ownOpenListenerId;
-    protected buildSubscribeMessage(symbol: string, _interval: CandleInterval): WsMessage;
-    protected buildUnsubscribeMessage(symbol: string, _interval: CandleInterval): WsMessage;
-    protected parseMessage(_data: string): {
-        symbol: string;
-        candle: CandleData;
-    } | null;
-    start(): void;
-    stop(): void;
-    subscribe(symbol: string, interval: CandleInterval): void;
-    unsubscribe(symbol: string, interval: CandleInterval): void;
-    onHistoricalDataFetched(symbol: string, interval: CandleInterval, candles: CandleData[]): void;
-    private applyCandleState;
-    private seedFromHistory;
-    private handleTradeMessage;
+    /** Subscribes to a market's candle stream; `symbol` is Lighter's numeric market id. */
+    protected buildSubscribeMessage(symbol: string, interval: CandleInterval): WsMessage;
+    /** Mirrors the subscribe channel — Lighter keys unsubscribes by the same slash-delimited name. */
+    protected buildUnsubscribeMessage(symbol: string, interval: CandleInterval): WsMessage;
+    /**
+     * Translates one candle message into CandleData, oldest first.
+     *
+     * Lighter batches updates every 500ms and, when a period rolls over, sends the just-closed candle
+     * followed by the newly opened one — both are emitted so the closed bar keeps its final trades.
+     */
+    protected parseMessages(data: string): ParsedCandle[];
 }
 
 export { LighterCandleWs };