@pear-protocol/market-sdk 0.0.13 → 0.1.0

package/dist/orderbook/ws/binance.js

@@ -1,14 +1,21 @@
 import { BaseDepthWs, parseStringLevels } from './base-depth';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 const BINANCE_DEPTH_REST = "https://fapi.binance.com/fapi/v1/depth";
-const toStreamName = (symbol) => `${symbol.toLowerCase()}@depth@100ms`;
+const toStreamName = /* @__PURE__ */ __name((symbol) => `${symbol.toLowerCase()}@depth@100ms`, "toStreamName");
 class BinanceDepthWs extends BaseDepthWs {
+  static {
+    __name(this, "BinanceDepthWs");
+  }
   idCounter = 1;
   symbolStates = /* @__PURE__ */ new Map();
   buildSubscribeMessage(symbol) {
     return {
       method: "SUBSCRIBE",
-      params: [toStreamName(symbol)],
+      params: [
+        toStreamName(symbol)
+      ],
       id: this.idCounter++
     };
   }
@@ -16,13 +23,18 @@ class BinanceDepthWs extends BaseDepthWs {
     this.symbolStates.delete(symbol);
     return {
       method: "UNSUBSCRIBE",
-      params: [toStreamName(symbol)],
+      params: [
+        toStreamName(symbol)
+      ],
       id: this.idCounter++
     };
   }
   subscribe(symbol) {
     if (this.symbolStates.has(symbol)) return;
-    this.symbolStates.set(symbol, { phase: "buffering", buffer: [] });
+    this.symbolStates.set(symbol, {
+      phase: "buffering",
+      buffer: []
+    });
     super.subscribe(symbol);
     this.bootstrap(symbol);
   }
@@ -54,7 +66,10 @@ class BinanceDepthWs extends BaseDepthWs {
       asks: parseStringLevels(snapshot.asks),
       ts: snapshot.E ?? Date.now()
     });
-    this.symbolStates.set(symbol, { phase: "syncing", lastUpdateId });
+    this.symbolStates.set(symbol, {
+      phase: "syncing",
+      lastUpdateId
+    });
     for (const event of buffered) {
       if (!this.processEvent(symbol, event)) {
         this.rebootstrap(symbol);
@@ -70,7 +85,10 @@ class BinanceDepthWs extends BaseDepthWs {
       if (!(payload.U <= state.lastUpdateId && payload.u >= state.lastUpdateId)) {
         return false;
       }
-      this.symbolStates.set(symbol, { phase: "ready", lastFinalUpdateId: payload.u });
+      this.symbolStates.set(symbol, {
+        phase: "ready",
+        lastFinalUpdateId: payload.u
+      });
       this.emitDelta(symbol, payload);
       return true;
     }
@@ -98,7 +116,10 @@ class BinanceDepthWs extends BaseDepthWs {
   }
   rebootstrap(symbol) {
     if (!this.symbolStates.has(symbol)) return;
-    this.symbolStates.set(symbol, { phase: "buffering", buffer: [] });
+    this.symbolStates.set(symbol, {
+      phase: "buffering",
+      buffer: []
+    });
     setTimeout(() => this.bootstrap(symbol), 1e3);
   }
   parseMessage(data) {

package/dist/orderbook/ws/bybit.js

@@ -1,16 +1,31 @@
 import { BaseDepthWs, parseStringLevels } from './base-depth';
 
-const toTopic = (symbol) => `orderbook.1000.${symbol}`;
-const fromTopic = (topic) => {
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const toTopic = /* @__PURE__ */ __name((symbol) => `orderbook.1000.${symbol}`, "toTopic");
+const fromTopic = /* @__PURE__ */ __name((topic) => {
   const parts = topic.split(".");
   return parts[2] ?? "";
-};
+}, "fromTopic");
 class BybitDepthWs extends BaseDepthWs {
+  static {
+    __name(this, "BybitDepthWs");
+  }
   buildSubscribeMessage(symbol) {
-    return { op: "subscribe", args: [toTopic(symbol)] };
+    return {
+      op: "subscribe",
+      args: [
+        toTopic(symbol)
+      ]
+    };
   }
   buildUnsubscribeMessage(symbol) {
-    return { op: "unsubscribe", args: [toTopic(symbol)] };
+    return {
+      op: "unsubscribe",
+      args: [
+        toTopic(symbol)
+      ]
+    };
   }
   parseMessage(data) {
     let msg;

package/dist/orderbook/ws/hyperliquid.js

@@ -1,27 +1,47 @@
 import { BaseDepthWs } from './base-depth';
 
-const parseLevels = (levels) => {
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const parseLevels = /* @__PURE__ */ __name((levels) => {
   if (!levels) return [];
-  return levels.map((l) => [l.px, Number(l.sz)]);
-};
+  return levels.map((l) => [
+    l.px,
+    Number(l.sz)
+  ]);
+}, "parseLevels");
 function computeSigFigs(bucketSize, currentPrice) {
   if (bucketSize <= 0 || currentPrice <= 0) return {};
   const priceMag = Math.floor(Math.log10(currentPrice));
   const bucketMag = Math.floor(Math.log10(bucketSize));
   const rawSigFigs = priceMag - bucketMag + 1;
   if (rawSigFigs < 2) return {};
-  if (rawSigFigs > 5) return { nSigFigs: null };
+  if (rawSigFigs > 5) return {
+    nSigFigs: null
+  };
   const nSigFigs = rawSigFigs;
-  if (nSigFigs < 5) return { nSigFigs };
+  if (nSigFigs < 5) return {
+    nSigFigs
+  };
   const ratio = bucketSize / 10 ** bucketMag;
-  const mantissaCandidates = [1, 2, 5];
-  const mantissa = mantissaCandidates.reduce(
-    (closest, candidate) => Math.abs(candidate - ratio) < Math.abs(closest - ratio) ? candidate : closest
-  );
-  if (mantissa === 1) return { nSigFigs: 5 };
-  return { nSigFigs: 5, mantissa };
+  const mantissaCandidates = [
+    1,
+    2,
+    5
+  ];
+  const mantissa = mantissaCandidates.reduce((closest, candidate) => Math.abs(candidate - ratio) < Math.abs(closest - ratio) ? candidate : closest);
+  if (mantissa === 1) return {
+    nSigFigs: 5
+  };
+  return {
+    nSigFigs: 5,
+    mantissa
+  };
 }
+__name(computeSigFigs, "computeSigFigs");
 class HyperliquidDepthWs extends BaseDepthWs {
+  static {
+    __name(this, "HyperliquidDepthWs");
+  }
   aggregation = 0;
   lastNSigFigs;
   lastMantissa;

package/dist/orderbook/ws/index.js

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

package/dist/orderbook/ws/lighter.js

@@ -1,14 +1,33 @@
 import { BaseDepthWs, parseStringLevels } from './base-depth';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 class LighterDepthWs extends BaseDepthWs {
+  static {
+    __name(this, "LighterDepthWs");
+  }
   snapshotReceived = /* @__PURE__ */ new Map();
   lastNonce = /* @__PURE__ */ new Map();
   resetListenerId = null;
   buildSubscribeMessage(symbol) {
-    return { type: "subscribe", channel: `order_book@tier2/${symbol}` };
+    const authToken = this.transport.authToken;
+    if (!authToken) {
+      return {
+        type: "subscribe",
+        channel: `order_book@tier2/${symbol}`
+      };
+    }
+    return {
+      type: "subscribe",
+      channel: `order_book@tier2/${symbol}`,
+      auth: authToken
+    };
   }
   buildUnsubscribeMessage(symbol) {
-    return { type: "unsubscribe", channel: `order_book@tier2/${symbol}` };
+    return {
+      type: "unsubscribe",
+      channel: `order_book@tier2/${symbol}`
+    };
   }
   start() {
     super.start();
@@ -44,9 +63,7 @@ class LighterDepthWs extends BaseDepthWs {
     if (!isSnapshot) {
       const prevNonce = this.lastNonce.get(symbol);
       if (prevNonce !== void 0 && book.begin_nonce !== prevNonce) {
-        console.warn(
-          `[LighterDepthWs] Sequence break on symbol ${symbol}: expected begin_nonce ${prevNonce}, got ${book.begin_nonce}. Resubscribing.`
-        );
+        console.warn(`[LighterDepthWs] Sequence break on symbol ${symbol}: expected begin_nonce ${prevNonce}, got ${book.begin_nonce}. Resubscribing.`);
         this.resubscribe(symbol);
         return null;
       }
@@ -56,8 +73,14 @@ class LighterDepthWs extends BaseDepthWs {
     return {
       symbol,
       type: isSnapshot ? "snapshot" : "delta",
-      bids: parseStringLevels(book.bids.map((l) => [l.price, l.size])),
-      asks: parseStringLevels(book.asks.map((l) => [l.price, l.size])),
+      bids: parseStringLevels(book.bids.map((l) => [
+        l.price,
+        l.size
+      ])),
+      asks: parseStringLevels(book.asks.map((l) => [
+        l.price,
+        l.size
+      ])),
       ts: msg.timestamp
     };
   }

package/dist/orderbook/ws/okx.js

@@ -1,11 +1,32 @@
 import { BaseDepthWs, parseStringLevels } from './base-depth';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 class OkxDepthWs extends BaseDepthWs {
+  static {
+    __name(this, "OkxDepthWs");
+  }
   buildSubscribeMessage(symbol) {
-    return { op: "subscribe", args: [{ channel: "books", instId: symbol }] };
+    return {
+      op: "subscribe",
+      args: [
+        {
+          channel: "books",
+          instId: symbol
+        }
+      ]
+    };
   }
   buildUnsubscribeMessage(symbol) {
-    return { op: "unsubscribe", args: [{ channel: "books", instId: symbol }] };
+    return {
+      op: "unsubscribe",
+      args: [
+        {
+          channel: "books",
+          instId: symbol
+        }
+      ]
+    };
   }
   parseMessage(data) {
     if (data === "pong") return null;

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

@@ -1,6 +1,11 @@
 import { WebSocket } from 'partysocket';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 class BaseTransport {
+  static {
+    __name(this, "BaseTransport");
+  }
   ws = null;
   pingTimer = null;
   messageListeners = /* @__PURE__ */ new Map();
@@ -50,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/binance.js

@@ -1,6 +1,11 @@
 import { BaseTransport } from './base-transport';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 class BinanceTransport extends BaseTransport {
+  static {
+    __name(this, "BinanceTransport");
+  }
   connector = "binance";
   getWsUrl() {
     return "wss://fstream.binance.com/ws";

package/dist/transport/bybit.js

@@ -1,6 +1,11 @@
 import { BaseTransport } from './base-transport';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 class BybitTransport extends BaseTransport {
+  static {
+    __name(this, "BybitTransport");
+  }
   connector = "bybit";
   getWsUrl() {
     return "wss://stream.bybit.com/v5/public/linear";
@@ -9,7 +14,9 @@ class BybitTransport extends BaseTransport {
     return 2e4;
   }
   buildPingMessage() {
-    return { op: "ping" };
+    return {
+      op: "ping"
+    };
   }
 }
 

package/dist/transport/hyperliquid.js

@@ -1,6 +1,11 @@
 import { BaseTransport } from './base-transport';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 class HyperliquidTransport extends BaseTransport {
+  static {
+    __name(this, "HyperliquidTransport");
+  }
   connector = "hyperliquid";
   getWsUrl() {
     return "wss://api.hyperliquid.xyz/ws";
@@ -9,7 +14,9 @@ class HyperliquidTransport extends BaseTransport {
     return 3e4;
   }
   buildPingMessage() {
-    return { method: "ping" };
+    return {
+      method: "ping"
+    };
   }
 }
 

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

@@ -5,7 +5,9 @@ import { HyperliquidTransport } from './hyperliquid';
 import { LighterTransport } from './lighter';
 import { OkxTransport } from './okx';
 
-function CreateTransport(connector) {
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function CreateTransport(connector, options) {
   switch (connector) {
     case "binance":
       return new BinanceTransport();
@@ -16,12 +18,13 @@ 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)}`);
     }
   }
 }
+__name(CreateTransport, "CreateTransport");
 
 export { CreateTransport };

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

@@ -1,15 +1,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" };
+    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;
+    }
   }
 }
 

package/dist/transport/okx.js

@@ -1,6 +1,11 @@
 import { BaseTransport } from './base-transport';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 class OkxTransport extends BaseTransport {
+  static {
+    __name(this, "OkxTransport");
+  }
   connector = "okx";
   getWsUrl() {
     return "wss://ws.okx.com:8443/ws/v5/public";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pear-protocol/market-sdk",
-  "version": "0.0.13",
+  "version": "0.1.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.0.0",
+    "@pear-protocol/types": "^1.28.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"
   }
 }