@pear-protocol/market-sdk 0.0.14 → 0.2.0

package/README.md

@@ -70,6 +70,33 @@ orderbook.destroy();
 transport.destroy();
 ```
 
+## Transport
+
+`CreateTransport(connector)` builds the connection every feature shares. Pass it to `Chart`,
+`Orderbook`, and `FundingRate`, then `destroy()` it once when you are done.
+
+### Lighter rate limits
+
+Lighter grants a wider rate limit to requests it can attribute to an account, on public market data
+as well as private endpoints. Supply a token provider and this SDK sends it on Lighter's candle and
+funding reads (`authorization` header) and on its candle and order-book subscriptions (`auth` field):
+
+```typescript
+import { CreateTransport } from '@pear-protocol/market-sdk';
+import { retrieveLighterAuthToken } from '@pear-protocol/exchanges-sdk';
+
+const transport = CreateTransport('lighter', {
+  authToken: () => retrieveLighterAuthToken(sdk, credentials, false),
+});
+```
+
+This SDK never holds Lighter credentials — the caller mints the token and owns its cache.
+`retrieveLighterAuthToken` is the same cache the account trackers use, so both SDKs share one token.
+
+Everything is optional. Omit `authToken`, or resolve `undefined` for a visitor with no connected
+account, and every request goes out anonymously. A failed mint logs a warning and falls back to
+anonymous rather than breaking the market data.
+
 ## Chart
 
 ### Initialization

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

@@ -1,9 +1,9 @@
 import { CandleInterval, CandleData, 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 class CandleCache {
     private historicalPriceData;

package/dist/chart/cache/index.js

@@ -81,7 +81,7 @@ class CandleCache {
     const key = createKey(symbol, interval);
     const tokenData = this.historicalPriceData[key];
     if (!tokenData) return [];
-    return tokenData.candles.filter((candle) => candle.t >= startTime && candle.t < endTime);
+    return tokenData.candles.filter((candle) => candle.T >= startTime && candle.t < endTime);
   }
   getEffectiveBoundary(symbols, interval) {
     if (symbols.length === 0) return null;

package/dist/chart/chart.d.ts

@@ -1,9 +1,9 @@
 import { ChartConfig, TokenSelection, CandleInterval, ChartType, Bar, RealtimeBarCallback } 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 class Chart {
     private collector;

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

@@ -1,9 +1,9 @@
 import { CandleInterval, CandleData } 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 fetchHistoricalCandles(symbol: string, startTime: number, endTime: number, interval: CandleInterval): Promise<CandleData[]>;
 

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

@@ -1,9 +1,9 @@
 import { CandleInterval, CandleData } 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 fetchHistoricalCandles(symbol: string, startTime: number, endTime: number, interval: CandleInterval): Promise<CandleData[]>;
 

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

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

package/dist/chart/collector/helpers.js

@@ -6,7 +6,7 @@ import { fetchHistoricalCandles as fetchHistoricalCandles$2 } from './okx';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-async function fetchHistoricalCandles(connector, symbol, startTime, endTime, interval) {
+async function fetchHistoricalCandles(connector, symbol, startTime, endTime, interval, authToken) {
   switch (connector) {
     case "hyperliquid":
       return fetchHistoricalCandles$5(symbol, startTime, endTime, interval);
@@ -17,7 +17,7 @@ async function fetchHistoricalCandles(connector, symbol, startTime, endTime, int
     case "okx":
       return fetchHistoricalCandles$2(symbol, startTime, endTime, interval);
     case "lighter":
-      return fetchHistoricalCandles$1(symbol, startTime, endTime, interval);
+      return fetchHistoricalCandles$1(symbol, startTime, endTime, interval, authToken);
     default:
       throw new Error(`Unsupported connector: ${connector}`);
   }

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

@@ -1,9 +1,9 @@
 import { CandleInterval, CandleData } 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 fetchHistoricalCandles(symbol: string, startTime: number, endTime: number, interval: CandleInterval): Promise<CandleData[]>;
 

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

@@ -1,9 +1,9 @@
 import { ChartConfig, TokenSelection, CandleInterval, RealtimeCandleCallback, CandleData } 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 class DataCollector {
     private transport;

package/dist/chart/collector/index.js

@@ -127,10 +127,11 @@ class DataCollector {
     for (const token of tokensToFetch) {
       this.cache.addLoadingToken(token.symbol);
     }
+    const authToken = await this.transport.retrieveAuthToken();
     try {
       const fetchPromises = tokensToFetch.map(async (token) => {
         try {
-          const candles = await fetchHistoricalCandles(this.transport.connector, token.symbol, startTime, endTime, interval);
+          const candles = await fetchHistoricalCandles(this.transport.connector, token.symbol, startTime, endTime, interval, authToken);
           this.cache.addHistoricalPriceData(token.symbol, interval, candles, {
             start: startTime,
             end: endTime

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

@@ -1,10 +1,10 @@
 import { CandleInterval, CandleData } 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 fetchHistoricalCandles(symbol: string, startTime: number, endTime: number, interval: CandleInterval): Promise<CandleData[]>;
+declare function fetchHistoricalCandles(symbol: string, startTime: number, endTime: number, interval: CandleInterval, authToken?: string): Promise<CandleData[]>;
 
 export { fetchHistoricalCandles };

package/dist/chart/collector/lighter.js

@@ -1,9 +1,11 @@
 import { getIntervalSeconds } from '../utils';
+import { getWeekStart, aggregateDailyCandlesToWeekly } from '../weekly';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 const BASE_URL = "https://mainnet.zklighter.elliot.ai";
 const MAX_LIMIT = 500;
+const DAY_MS = getIntervalSeconds("1d") * 1e3;
 const RESOLUTION_MAP = {
   "1m": "1m",
   "5m": "5m",
@@ -14,7 +16,25 @@ const RESOLUTION_MAP = {
   "12h": "12h",
   "1d": "1d"
 };
-async function fetchHistoricalCandles(symbol, startTime, endTime, interval) {
+async function fetchHistoricalCandles(symbol, startTime, endTime, interval, authToken) {
+  if (interval === "1w") {
+    const dailyCandles = await fetchDailyCandlesChunked(symbol, getWeekStart(startTime), endTime, authToken);
+    return aggregateDailyCandlesToWeekly(dailyCandles);
+  }
+  return fetchResolutionCandles(symbol, startTime, endTime, interval, authToken);
+}
+__name(fetchHistoricalCandles, "fetchHistoricalCandles");
+async function fetchDailyCandlesChunked(symbol, startTime, endTime, authToken) {
+  const chunkMs = MAX_LIMIT * DAY_MS;
+  const chunkStarts = [];
+  for (let chunkStart = startTime; chunkStart < endTime; chunkStart += chunkMs) {
+    chunkStarts.push(chunkStart);
+  }
+  const chunks = await Promise.all(chunkStarts.map((chunkStart) => fetchResolutionCandles(symbol, chunkStart, Math.min(chunkStart + chunkMs, endTime), "1d", authToken)));
+  return chunks.flat();
+}
+__name(fetchDailyCandlesChunked, "fetchDailyCandlesChunked");
+async function fetchResolutionCandles(symbol, startTime, endTime, interval, authToken) {
   const resolution = RESOLUTION_MAP[interval];
   if (!resolution) throw new Error(`Lighter does not support the '${interval}' interval`);
   const intervalMs = getIntervalSeconds(interval) * 1e3;
@@ -26,7 +46,11 @@ async function fetchHistoricalCandles(symbol, startTime, endTime, interval) {
     end_timestamp: String(endTime),
     count_back: String(countBack)
   });
-  const response = await fetch(`${BASE_URL}/api/v1/candles?${params}`);
+  const response = await fetch(`${BASE_URL}/api/v1/candles?${params}`, authToken ? {
+    headers: {
+      authorization: authToken
+    }
+  } : void 0);
   if (!response.ok) throw new Error(`Lighter API error: ${response.status} ${response.statusText}`);
   const data = await response.json();
   if (data.code !== 200) throw new Error(`Lighter API error: ${data.message ?? String(data.code)}`);
@@ -39,6 +63,6 @@ async function fetchHistoricalCandles(symbol, startTime, endTime, interval) {
     c: candle.c ?? 0
   }));
 }
-__name(fetchHistoricalCandles, "fetchHistoricalCandles");
+__name(fetchResolutionCandles, "fetchResolutionCandles");
 
 export { fetchHistoricalCandles };

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

@@ -1,9 +1,9 @@
 import { CandleInterval, CandleData } 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 fetchHistoricalCandles(instId: string, startTime: number, endTime: number, interval: CandleInterval): Promise<CandleData[]>;
 

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

@@ -1,9 +1,9 @@
 import { 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 computeAssetBars(tokenCandles: Record<string, CandleData[]>, symbol: string): Bar[];
 declare function computeRealtimeAssetBar(snapshot: Record<string, CandleData>, symbol: string): Bar | null;

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

@@ -5,6 +5,6 @@ export { computeRealtimeWeightedRatioBar, computeWeightedRatioCandles } from './
 import '../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';

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

@@ -1,9 +1,9 @@
 import { TokenSelection, CandleData, PerformanceResult, 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 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;

package/dist/chart/compute/price-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 computePriceRatioCandles(longTokens: TokenSelection[], shortTokens: TokenSelection[], tokenCandles: Record<string, CandleData[]>): Bar[];
 declare function computeRealtimePriceRatioBar(longTokens: TokenSelection[], shortTokens: TokenSelection[], snapshot: Record<string, CandleData>): Bar | null;

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/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/weekly.d.ts

@@ -0,0 +1,20 @@
+import { CandleData } from './types.js';
+import '../transport/index.js';
+import '@pear-protocol/types';
+import '../shared/types.js';
+import '../transport/base-transport.js';
+import 'partysocket';
+
+/** Start (ms epoch, UTC) of the Monday-aligned week containing `timestamp`. */
+declare function getWeekStart(timestamp: number): number;
+/**
+ * Folds one daily candle into its week's running OHLC bar. Extends `existing` when it already
+ * covers the same week (open stays, high/low/close roll forward); otherwise starts a fresh bar.
+ * Shared by the REST batch aggregator below and LighterCandleWs's live incremental merge, so
+ * historical and realtime weekly candles are always built the same way.
+ */
+declare function foldDayIntoWeek(existing: CandleData | undefined, day: CandleData): CandleData;
+/** Reduces a batch of daily candles into one OHLC candle per UTC week, oldest first. */
+declare function aggregateDailyCandlesToWeekly(dailyCandles: CandleData[]): CandleData[];
+
+export { aggregateDailyCandlesToWeekly, foldDayIntoWeek, getWeekStart };

package/dist/chart/weekly.js

@@ -0,0 +1,46 @@
+import { getIntervalSeconds } from './utils';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const WEEK_MS = getIntervalSeconds("1w") * 1e3;
+function getWeekStart(timestamp) {
+  const date = new Date(timestamp);
+  const mondayOffset = (date.getUTCDay() + 6) % 7;
+  const monday = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+  monday.setUTCDate(monday.getUTCDate() - mondayOffset);
+  return monday.getTime();
+}
+__name(getWeekStart, "getWeekStart");
+function foldDayIntoWeek(existing, day) {
+  const weekStart = getWeekStart(day.t);
+  if (existing && existing.t === weekStart) {
+    return {
+      ...existing,
+      h: Math.max(existing.h, day.h),
+      l: Math.min(existing.l, day.l),
+      c: day.c
+    };
+  }
+  return {
+    t: weekStart,
+    T: weekStart + WEEK_MS - 1,
+    o: day.o,
+    h: day.h,
+    l: day.l,
+    c: day.c
+  };
+}
+__name(foldDayIntoWeek, "foldDayIntoWeek");
+function aggregateDailyCandlesToWeekly(dailyCandles) {
+  const weeklyByStart = /* @__PURE__ */ new Map();
+  for (const day of [
+    ...dailyCandles
+  ].sort((a, b) => a.t - b.t)) {
+    const folded = foldDayIntoWeek(weeklyByStart.get(getWeekStart(day.t)), day);
+    weeklyByStart.set(folded.t, folded);
+  }
+  return Array.from(weeklyByStart.values()).sort((a, b) => a.t - b.t);
+}
+__name(aggregateDailyCandlesToWeekly, "aggregateDailyCandlesToWeekly");
+
+export { aggregateDailyCandlesToWeekly, foldDayIntoWeek, getWeekStart };

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

@@ -1,5 +1,5 @@
 import { WsMessage } from '../../shared/types.js';
-import { CandleInterval } from '../types.js';
+import { CandleInterval, CandleData } from '../types.js';
 import { BaseCandleWs, ParsedCandle } from './base-candle.js';
 import '../../transport/index.js';
 import '@pear-protocol/types';
@@ -11,13 +11,29 @@ import 'partysocket';
  * 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
+ *
+ * Exception: Lighter has no weekly channel. A '1w' subscription rides the native daily channel
+ * instead and this class folds each incoming daily candle into a running weekly bar client-side
+ * (see foldDayIntoWeek in chart/weekly.ts) — still no REST call of its own; the weekly seed comes
+ * from onHistoricalDataFetched, fed by DataCollector's already-synthesized weekly history.
  */
 
 declare class LighterCandleWs extends BaseCandleWs {
+    private weeklyCandles;
+    private weeklyTrackedSymbols;
     /** 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;
+    /**
+     * Seeds the running weekly bar from the REST-aggregated weekly history, so the first live
+     * daily tick extends the correct week's open/high/low instead of starting a bar from today.
+     *
+     * DataCollector calls this for every historical fetch, including a backfill for an older
+     * range while a live subscription is already running (e.g. scrolling a chart back in time) —
+     * so a batch's last candle is not necessarily the current live week.
+     */
+    onHistoricalDataFetched(symbol: string, interval: CandleInterval, candles: CandleData[]): void;
     /**
      * Translates one candle message into CandleData, oldest first.
      *
@@ -25,6 +41,8 @@ declare class LighterCandleWs extends BaseCandleWs {
      * followed by the newly opened one — both are emitted so the closed bar keeps its final trades.
      */
     protected parseMessages(data: string): ParsedCandle[];
+    /** Folds one live daily candle into the symbol's running weekly bar and records the result. */
+    private mergeIntoWeeklyCandle;
 }
 
 export { LighterCandleWs };

package/dist/chart/ws/lighter.js

@@ -1,4 +1,5 @@
 import { getIntervalSeconds } from '../utils';
+import { foldDayIntoWeek } from '../weekly';
 import { BaseCandleWs } from './base-candle';
 
 var __defProp = Object.defineProperty;
@@ -17,21 +18,74 @@ class LighterCandleWs extends BaseCandleWs {
   static {
     __name(this, "LighterCandleWs");
   }
+  // Per-symbol running weekly bar, kept only while that symbol is subscribed at the synthesized '1w'.
+  weeklyCandles = /* @__PURE__ */ new Map();
+  weeklyTrackedSymbols = /* @__PURE__ */ new Set();
   /** Subscribes to a market's candle stream; `symbol` is Lighter's numeric market id. */
   buildSubscribeMessage(symbol, interval) {
+    const resolution = interval === "1w" ? "1d" : interval;
+    if (interval === "1w") {
+      this.weeklyTrackedSymbols.add(symbol);
+    }
+    const authToken = this.transport.authToken;
+    if (!authToken) {
+      return {
+        type: "subscribe",
+        channel: `candle/${symbol}/${resolution}`
+      };
+    }
     return {
       type: "subscribe",
-      channel: `candle/${symbol}/${interval}`
+      channel: `candle/${symbol}/${resolution}`,
+      auth: authToken
     };
   }
   /** Mirrors the subscribe channel — Lighter keys unsubscribes by the same slash-delimited name. */
   buildUnsubscribeMessage(symbol, interval) {
+    const resolution = interval === "1w" ? "1d" : interval;
+    if (interval === "1w") {
+      this.weeklyTrackedSymbols.delete(symbol);
+      this.weeklyCandles.delete(symbol);
+    }
     return {
       type: "unsubscribe",
-      channel: `candle/${symbol}/${interval}`
+      channel: `candle/${symbol}/${resolution}`
     };
   }
   /**
+  * Seeds the running weekly bar from the REST-aggregated weekly history, so the first live
+  * daily tick extends the correct week's open/high/low instead of starting a bar from today.
+  *
+  * DataCollector calls this for every historical fetch, including a backfill for an older
+  * range while a live subscription is already running (e.g. scrolling a chart back in time) —
+  * so a batch's last candle is not necessarily the current live week.
+  */
+  onHistoricalDataFetched(symbol, interval, candles) {
+    if (interval !== "1w") {
+      return;
+    }
+    const latest = candles[candles.length - 1];
+    if (!latest) {
+      return;
+    }
+    const tracked = this.weeklyCandles.get(symbol);
+    if (tracked && latest.t < tracked.t) {
+      return;
+    }
+    if (tracked && latest.t === tracked.t) {
+      this.weeklyCandles.set(symbol, {
+        t: tracked.t,
+        T: tracked.T,
+        o: tracked.o,
+        h: Math.max(tracked.h, latest.h),
+        l: Math.min(tracked.l, latest.l),
+        c: tracked.c
+      });
+      return;
+    }
+    this.weeklyCandles.set(symbol, latest);
+  }
+  /**
   * Translates one candle message into CandleData, oldest first.
   *
   * Lighter batches updates every 500ms and, when a period rolls over, sends the just-closed candle
@@ -55,11 +109,18 @@ class LighterCandleWs extends BaseCandleWs {
       return [];
     }
     const intervalMs = getIntervalSeconds(route.interval) * 1e3;
+    const isWeeklyTracked = route.interval === "1d" && this.weeklyTrackedSymbols.has(route.symbol);
     return message.candles.map((candle) => ({
       symbol: route.symbol,
-      candle: toCandleData(candle, intervalMs)
+      candle: isWeeklyTracked ? this.mergeIntoWeeklyCandle(route.symbol, toCandleData(candle, intervalMs)) : toCandleData(candle, intervalMs)
     }));
   }
+  /** Folds one live daily candle into the symbol's running weekly bar and records the result. */
+  mergeIntoWeeklyCandle(symbol, day) {
+    const weekly = foldDayIntoWeek(this.weeklyCandles.get(symbol), day);
+    this.weeklyCandles.set(symbol, weekly);
+    return weekly;
+  }
 }
 function parseChannel(channel) {
   if (!channel) {

package/dist/funding-rate/fetcher/binance.d.ts

@@ -1,9 +1,9 @@
 import { FundingRateEntry } 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 fetchHistoricalFundingRates(symbol: string, startTime: number, endTime: number): Promise<FundingRateEntry[]>;
 

package/dist/funding-rate/fetcher/bybit.d.ts

@@ -1,9 +1,9 @@
 import { FundingRateEntry } 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 fetchHistoricalFundingRates(symbol: string, startTime: number, endTime: number): Promise<FundingRateEntry[]>;
 

package/dist/funding-rate/fetcher/http-client.d.ts

@@ -1,5 +1,5 @@
 type ResponseValidator<T> = (data: T) => string | undefined;
-declare function httpGet<T>(url: string, params: Record<string, string>, validate?: ResponseValidator<T>): Promise<T>;
+declare function httpGet<T>(url: string, params: Record<string, string>, validate?: ResponseValidator<T>, headers?: Record<string, string>): Promise<T>;
 declare function httpPost<T>(url: string, body: unknown, validate?: ResponseValidator<T>): Promise<T>;
 
 export { type ResponseValidator, httpGet, httpPost };

package/dist/funding-rate/fetcher/http-client.js

@@ -2,9 +2,11 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 const BASE_DELAY_MS = 1e3;
 const MAX_DELAY_MS = 6e4;
-async function httpGet(url, params, validate) {
+async function httpGet(url, params, validate, headers) {
   const qs = new URLSearchParams(params).toString();
-  return httpFetch(`${url}?${qs}`, void 0, validate);
+  return httpFetch(`${url}?${qs}`, headers ? {
+    headers
+  } : void 0, validate);
 }
 __name(httpGet, "httpGet");
 async function httpPost(url, body, validate) {

package/dist/funding-rate/fetcher/hyperliquid.d.ts

@@ -1,9 +1,9 @@
 import { FundingRateEntry } 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 fetchHistoricalFundingRates(symbol: string, startTime: number, endTime: number): Promise<FundingRateEntry[]>;
 

package/dist/funding-rate/fetcher/index.d.ts

@@ -1,10 +1,10 @@
 import { Connector } from '@pear-protocol/types';
 import { FundingRateDuration, FundingRateEntry } from '../types.js';
 import '../../transport/index.js';
+import '../../shared/types.js';
 import '../../transport/base-transport.js';
 import 'partysocket';
-import '../../shared/types.js';
 
-declare function fetchHistoricalFundingRates(connector: Connector, symbol: string, startTime: number, endTime: number, duration: FundingRateDuration): Promise<FundingRateEntry[]>;
+declare function fetchHistoricalFundingRates(connector: Connector, symbol: string, startTime: number, endTime: number, duration: FundingRateDuration, authToken?: string): Promise<FundingRateEntry[]>;
 
 export { fetchHistoricalFundingRates };

package/dist/funding-rate/fetcher/index.js

@@ -6,7 +6,7 @@ import { fetchHistoricalFundingRates as fetchHistoricalFundingRates$2 } from './
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-async function fetchHistoricalFundingRates(connector, symbol, startTime, endTime, duration) {
+async function fetchHistoricalFundingRates(connector, symbol, startTime, endTime, duration, authToken) {
   switch (connector) {
     case "hyperliquid":
       return fetchHistoricalFundingRates$5(symbol, startTime, endTime);
@@ -17,7 +17,7 @@ async function fetchHistoricalFundingRates(connector, symbol, startTime, endTime
     case "okx":
       return fetchHistoricalFundingRates$2(symbol, startTime, endTime);
     case "lighter":
-      return fetchHistoricalFundingRates$1(symbol, startTime, endTime, duration);
+      return fetchHistoricalFundingRates$1(symbol, startTime, endTime, duration, authToken);
     default:
       throw new Error(`Unsupported connector: ${connector}`);
   }

package/dist/funding-rate/fetcher/lighter.d.ts

@@ -1,10 +1,10 @@
 import { FundingRateDuration, FundingRateEntry } 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 fetchHistoricalFundingRates(symbol: string, startTime: number, endTime: number, _duration: FundingRateDuration): Promise<FundingRateEntry[]>;
+declare function fetchHistoricalFundingRates(symbol: string, startTime: number, endTime: number, _duration: FundingRateDuration, authToken?: string): Promise<FundingRateEntry[]>;
 
 export { fetchHistoricalFundingRates };

package/dist/funding-rate/fetcher/lighter.js

@@ -5,7 +5,7 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 const BASE_URL = "https://mainnet.zklighter.elliot.ai";
 const MAX_LIMIT = 500;
-async function fetchHistoricalFundingRates(symbol, startTime, endTime, _duration) {
+async function fetchHistoricalFundingRates(symbol, startTime, endTime, _duration, authToken) {
   const intervalMs = 60 * 60 * 1e3;
   const allRates = [];
   let cursor = startTime;
@@ -17,7 +17,9 @@ async function fetchHistoricalFundingRates(symbol, startTime, endTime, _duration
       start_timestamp: String(cursor),
       end_timestamp: String(endTime),
       count_back: String(countBack)
-    });
+    }, void 0, authToken ? {
+      authorization: authToken
+    } : void 0);
     const entries = data.fundings ?? [];
     if (entries.length === 0) break;
     for (const entry of entries) {

package/dist/funding-rate/fetcher/okx.d.ts

@@ -1,9 +1,9 @@
 import { FundingRateEntry } 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 fetchHistoricalFundingRates(instId: string, startTime: number, endTime: number): Promise<FundingRateEntry[]>;
 

package/dist/funding-rate/funding-rate.d.ts

@@ -1,9 +1,9 @@
 import { FundingRateConfig, TokenSelection, FundingRateAggregation, FundingRateDuration, FundingRateEntry } 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 class FundingRate {
     private transport;

package/dist/funding-rate/funding-rate.js

@@ -88,12 +88,13 @@ class FundingRate {
   }
   async refetch(tokens, start, end, duration) {
     if (tokens.length === 0) return;
+    const authToken = await this.transport.retrieveAuthToken();
     await Promise.all(tokens.map(async (token) => {
       const existing = this.cache[token.symbol];
       const fetchStart = existing ? Math.min(start, existing.start) : start;
       const fetchEnd = existing ? Math.max(end, existing.end) : end;
       try {
-        const rates = await fetchHistoricalFundingRates(this.transport.connector, token.symbol, fetchStart, fetchEnd, duration);
+        const rates = await fetchHistoricalFundingRates(this.transport.connector, token.symbol, fetchStart, fetchEnd, duration, authToken);
         this.cache[token.symbol] = {
           entries: rates,
           start: fetchStart,

package/dist/funding-rate/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/funding-rate/utils.d.ts

@@ -1,9 +1,9 @@
 import { FundingRateEntry, FundingRateAggregation, TokenSelection, FundingRateDuration } 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 computeStartTime(endTime: number, duration: FundingRateDuration): number;
 declare function aggregateRates(rawRates: FundingRateEntry[], aggregation: FundingRateAggregation): FundingRateEntry[];

package/dist/index.d.ts

@@ -5,8 +5,8 @@ export { FundingRateAggregation, FundingRateConfig, FundingRateDuration, Funding
 export { Orderbook } from './orderbook/orderbook.js';
 export { AggregationConfig, BBO, CexAggregationConfig, HyperliquidAggregationConfig, OrderbookCallback, OrderbookConfig, OrderbookLevel, OrderbookSnapshot } from './orderbook/types.js';
 export { getAvailableAggregations } from './orderbook/utils.js';
-export { CreateTransport, Transport } from './transport/index.js';
+export { AuthTokenProvider } from './shared/types.js';
+export { CreateTransport, Transport, TransportOptions } from './transport/index.js';
 export { BaseTransport } from './transport/base-transport.js';
 import '@pear-protocol/types';
 import 'partysocket';
-import './shared/types.js';

package/dist/orderbook/book/aggregate.d.ts

@@ -2,9 +2,9 @@ import { OrderbookLevel } from '../types.js';
 import { LocalBook } from './local-book.js';
 import '../../transport/index.js';
 import '@pear-protocol/types';
+import '../../shared/types.js';
 import '../../transport/base-transport.js';
 import 'partysocket';
-import '../../shared/types.js';
 
 /**
  * Pure aggregation of a LocalBook into top-N bid/ask buckets at the given

package/dist/orderbook/book/local-book.d.ts

@@ -1,9 +1,9 @@
 import { BBO } 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';
 
 type Level = readonly [price: string, size: number];
 declare class LocalBook {

package/dist/orderbook/orderbook.d.ts

@@ -1,9 +1,9 @@
 import { OrderbookConfig, OrderbookCallback, OrderbookSnapshot, BBO } 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';
 
 /**
  * Orderbook exposes an aggregated top-of-book view for a single symbol.

package/dist/orderbook/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';
 
 declare const DEFAULT_DEPTH = 10;
 declare const DEFAULT_MULTIPLIERS: number[];

package/dist/orderbook/utils.d.ts

@@ -1,9 +1,9 @@
 import { Connector } from '@pear-protocol/types';
 import { AggregationConfig } from './types.js';
 import '../transport/index.js';
+import '../shared/types.js';
 import '../transport/base-transport.js';
 import 'partysocket';
-import '../shared/types.js';
 
 declare function getCexAvailableAggregations(tickSize: number, midPrice: number, multipliers?: number[]): number[];
 declare function getHyperliquidAvailableAggregations(maxDecimals: number, midPrice: number, multipliers?: number[]): number[];

package/dist/orderbook/ws/lighter.js

@@ -10,9 +10,17 @@ class LighterDepthWs extends BaseDepthWs {
   lastNonce = /* @__PURE__ */ new Map();
   resetListenerId = null;
   buildSubscribeMessage(symbol) {
+    const authToken = this.transport.authToken;
+    if (!authToken) {
+      return {
+        type: "subscribe",
+        channel: `order_book@tier2/${symbol}`
+      };
+    }
     return {
       type: "subscribe",
-      channel: `order_book@tier2/${symbol}`
+      channel: `order_book@tier2/${symbol}`,
+      auth: authToken
     };
   }
   buildUnsubscribeMessage(symbol) {

package/dist/shared/types.d.ts

@@ -2,5 +2,10 @@ interface WsMessage {
     [key: string]: unknown;
 }
 type MessageListener = (data: string) => void;
+/**
+ * Mints the identity a venue rate-limits by. Supplied by the caller, which owns the credentials and
+ * the token cache; resolving `undefined` keeps the traffic anonymous.
+ */
+type AuthTokenProvider = () => Promise<string | undefined>;
 
-export type { MessageListener, WsMessage };
+export type { AuthTokenProvider, MessageListener, WsMessage };

package/dist/transport/base-transport.d.ts

@@ -15,6 +15,10 @@ declare abstract class BaseTransport {
     connect(): void;
     disconnect(): void;
     get connected(): boolean;
+    /** The identity already in hand, for venues that widen rate limits for a known account. */
+    get authToken(): string | undefined;
+    /** Resolves a live identity for the next request; a venue without one stays anonymous. */
+    retrieveAuthToken(): Promise<string | undefined>;
     send(msg: WsMessage | string): void;
     addMessageListener(listener: MessageListener): string;
     removeMessageListener(id: string): void;

package/dist/transport/base-transport.js

@@ -55,6 +55,14 @@ class BaseTransport {
   get connected() {
     return this.ws?.readyState === WebSocket.OPEN;
   }
+  /** The identity already in hand, for venues that widen rate limits for a known account. */
+  get authToken() {
+    return void 0;
+  }
+  /** Resolves a live identity for the next request; a venue without one stays anonymous. */
+  retrieveAuthToken() {
+    return Promise.resolve(void 0);
+  }
   send(msg) {
     if (this.ws?.readyState === WebSocket.OPEN) {
       this.ws.send(typeof msg === "string" ? msg : JSON.stringify(msg));

package/dist/transport/index.d.ts

@@ -1,10 +1,18 @@
 import { Connector } from '@pear-protocol/types';
+import { AuthTokenProvider } from '../shared/types.js';
 import { BaseTransport } from './base-transport.js';
 import 'partysocket';
-import '../shared/types.js';
 
 type Transport = BaseTransport;
 
-declare function CreateTransport(connector: Connector): Transport;
+interface TransportOptions {
+    /**
+     * Mints the token that attributes this transport's traffic to a connected account. Only Lighter
+     * reads it today, where an authenticated request earns a wider rate limit on public market data.
+     * Omit it — or resolve `undefined` — to stay anonymous.
+     */
+    authToken?: AuthTokenProvider;
+}
+declare function CreateTransport(connector: Connector, options?: TransportOptions): Transport;
 
-export { BaseTransport, CreateTransport, type Transport };
+export { BaseTransport, CreateTransport, type Transport, type TransportOptions };

package/dist/transport/index.js

@@ -7,7 +7,7 @@ import { OkxTransport } from './okx';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-function CreateTransport(connector) {
+function CreateTransport(connector, options) {
   switch (connector) {
     case "binance":
       return new BinanceTransport();
@@ -18,7 +18,7 @@ function CreateTransport(connector) {
     case "hyperliquid":
       return new HyperliquidTransport();
     case "lighter":
-      return new LighterTransport();
+      return new LighterTransport(options?.authToken);
     default: {
       const _exhaustive = connector;
       throw new Error(`Unsupported connector: ${String(_exhaustive)}`);

package/dist/transport/lighter.d.ts

@@ -1,13 +1,43 @@
 import { Connector } from '@pear-protocol/types';
-import { WsMessage } from '../shared/types.js';
+import { AuthTokenProvider, WsMessage } from '../shared/types.js';
 import { BaseTransport } from './base-transport.js';
 import 'partysocket';
 
+/**
+ * Lighter's transport carries the connected account's identity alongside the socket, because the
+ * venue widens rate limits for authenticated traffic on otherwise public market data. The token is
+ * supplied by the caller — this package never holds Lighter credentials.
+ */
+
 declare class LighterTransport extends BaseTransport {
     readonly connector: Connector;
+    private readonly authTokenProvider;
+    private cachedAuthToken;
+    private authRefreshTimer;
+    private mintInFlight;
+    private wantsConnection;
+    /** Takes the caller's minter; without one this transport stays anonymous for its whole life. */
+    constructor(authTokenProvider?: AuthTokenProvider);
+    /** Holds the socket until a first token lands, so the opening subscriptions carry it. */
+    connect(): void;
+    /** Tears the socket down and drops the identity that belonged to it. */
+    disconnect(): void;
+    /** Exposes the cached token to the subscription frames, which are built synchronously. */
+    get authToken(): string | undefined;
+    /** Refreshes the cached token; the caller's provider owns expiry and request coalescing. */
+    retrieveAuthToken(): Promise<string | undefined>;
+    /** The venue's public market-data stream, which serves both authenticated and anonymous traffic. */
     protected getWsUrl(): string;
+    /** How often the socket must speak to stay open. */
     protected getPingIntervalMs(): number;
+    /** The keep-alive frame the venue expects. */
     protected buildPingMessage(): WsMessage;
+    /** Opens the socket and keeps the token fresh for as long as it stays open. */
+    private openSocket;
+    /** Re-mints the cached token on a timer, because reconnects resubscribe without warning. */
+    private startAuthRefresh;
+    /** Stops the re-minting timer, so a closed socket costs nothing. */
+    private stopAuthRefresh;
 }
 
 export { LighterTransport };

package/dist/transport/lighter.js

@@ -2,22 +2,100 @@ import { BaseTransport } from './base-transport';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const AUTH_REFRESH_INTERVAL_MS = 6e4;
 class LighterTransport extends BaseTransport {
   static {
     __name(this, "LighterTransport");
   }
   connector = "lighter";
+  authTokenProvider;
+  cachedAuthToken;
+  authRefreshTimer = null;
+  mintInFlight = false;
+  wantsConnection = false;
+  /** Takes the caller's minter; without one this transport stays anonymous for its whole life. */
+  constructor(authTokenProvider) {
+    super();
+    this.authTokenProvider = authTokenProvider;
+  }
+  /** Holds the socket until a first token lands, so the opening subscriptions carry it. */
+  connect() {
+    this.wantsConnection = true;
+    if (!this.authTokenProvider || this.cachedAuthToken) {
+      this.openSocket();
+      return;
+    }
+    if (this.mintInFlight) {
+      return;
+    }
+    this.mintInFlight = true;
+    void this.retrieveAuthToken().then(() => {
+      this.mintInFlight = false;
+      if (!this.wantsConnection) {
+        this.cachedAuthToken = void 0;
+        return;
+      }
+      this.openSocket();
+    });
+  }
+  /** Tears the socket down and drops the identity that belonged to it. */
+  disconnect() {
+    this.wantsConnection = false;
+    this.stopAuthRefresh();
+    this.cachedAuthToken = void 0;
+    super.disconnect();
+  }
+  /** Exposes the cached token to the subscription frames, which are built synchronously. */
+  get authToken() {
+    return this.cachedAuthToken;
+  }
+  /** Refreshes the cached token; the caller's provider owns expiry and request coalescing. */
+  async retrieveAuthToken() {
+    if (!this.authTokenProvider) {
+      return void 0;
+    }
+    try {
+      this.cachedAuthToken = await this.authTokenProvider();
+    } catch (error) {
+      console.warn("Failed to mint Lighter auth token, keeping the identity already in hand", error);
+    }
+    return this.cachedAuthToken;
+  }
+  /** The venue's public market-data stream, which serves both authenticated and anonymous traffic. */
   getWsUrl() {
     return "wss://mainnet.zklighter.elliot.ai/stream";
   }
+  /** How often the socket must speak to stay open. */
   getPingIntervalMs() {
     return 6e4;
   }
+  /** The keep-alive frame the venue expects. */
   buildPingMessage() {
     return {
       type: "ping"
     };
   }
+  /** Opens the socket and keeps the token fresh for as long as it stays open. */
+  openSocket() {
+    super.connect();
+    this.startAuthRefresh();
+  }
+  /** Re-mints the cached token on a timer, because reconnects resubscribe without warning. */
+  startAuthRefresh() {
+    if (!this.authTokenProvider || this.authRefreshTimer) {
+      return;
+    }
+    this.authRefreshTimer = setInterval(() => {
+      void this.retrieveAuthToken();
+    }, AUTH_REFRESH_INTERVAL_MS);
+  }
+  /** Stops the re-minting timer, so a closed socket costs nothing. */
+  stopAuthRefresh() {
+    if (this.authRefreshTimer) {
+      clearInterval(this.authRefreshTimer);
+      this.authRefreshTimer = null;
+    }
+  }
 }
 
 export { LighterTransport };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pear-protocol/market-sdk",
-  "version": "0.0.14",
+  "version": "0.2.0",
   "description": "Pear Protocol Market SDK",
   "private": false,
   "type": "module",
@@ -22,16 +22,18 @@
   "scripts": {
     "build": "tsup",
     "clean": "rm -rf dist .turbo",
+    "test": "vitest run",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@pear-protocol/types": "^1.26.0",
+    "@pear-protocol/types": "^1.30.0",
     "bignumber.js": "^9.1.2",
     "partysocket": "^1.0.3"
   },
   "devDependencies": {
     "@backend/typescript-config": "workspace:*",
     "tsup": "8.5.1",
-    "typescript": "5.9.3"
+    "typescript": "5.9.3",
+    "vitest": "4.1.2"
   }
 }