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

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

@@ -0,0 +1,23 @@
+import { WsMessage } from '../../shared/types.js';
+import { DepthUpdate } from '../types.js';
+import { BaseDepthWs } from './base-depth.js';
+import '../../transport/index.js';
+import '@pear-protocol/types';
+import '../../transport/base-transport.js';
+import 'partysocket';
+
+declare class BinanceDepthWs extends BaseDepthWs {
+    private idCounter;
+    private symbolStates;
+    protected buildSubscribeMessage(symbol: string): WsMessage;
+    protected buildUnsubscribeMessage(symbol: string): WsMessage;
+    subscribe(symbol: string): void;
+    private bootstrap;
+    private applySnapshot;
+    private processEvent;
+    private emitDelta;
+    private rebootstrap;
+    protected parseMessage(data: string): DepthUpdate | null;
+}
+
+export { BinanceDepthWs };

package/dist/orderbook/ws/binance.js

@@ -0,0 +1,126 @@
+import { BaseDepthWs, parseStringLevels } from './base-depth';
+
+const BINANCE_DEPTH_REST = "https://fapi.binance.com/fapi/v1/depth";
+const toStreamName = (symbol) => `${symbol.toLowerCase()}@depth@100ms`;
+class BinanceDepthWs extends BaseDepthWs {
+  idCounter = 1;
+  symbolStates = /* @__PURE__ */ new Map();
+  buildSubscribeMessage(symbol) {
+    return {
+      method: "SUBSCRIBE",
+      params: [toStreamName(symbol)],
+      id: this.idCounter++
+    };
+  }
+  buildUnsubscribeMessage(symbol) {
+    this.symbolStates.delete(symbol);
+    return {
+      method: "UNSUBSCRIBE",
+      params: [toStreamName(symbol)],
+      id: this.idCounter++
+    };
+  }
+  subscribe(symbol) {
+    this.symbolStates.set(symbol, { phase: "buffering", buffer: [] });
+    super.subscribe(symbol);
+    this.bootstrap(symbol);
+  }
+  async bootstrap(symbol) {
+    try {
+      const url = `${BINANCE_DEPTH_REST}?symbol=${symbol}&limit=1000`;
+      const res = await fetch(url);
+      if (!res.ok) {
+        console.warn(`Binance depth snapshot failed for ${symbol}: ${res.status}`);
+        this.rebootstrap(symbol);
+        return;
+      }
+      const snapshot = await res.json();
+      this.applySnapshot(symbol, snapshot);
+    } catch (err) {
+      console.warn("Binance depth snapshot fetch error:", err);
+      this.rebootstrap(symbol);
+    }
+  }
+  applySnapshot(symbol, snapshot) {
+    const state = this.symbolStates.get(symbol);
+    if (!state || state.phase !== "buffering") return;
+    const { lastUpdateId } = snapshot;
+    const buffered = state.buffer;
+    this.onUpdate({
+      symbol,
+      type: "snapshot",
+      bids: parseStringLevels(snapshot.bids),
+      asks: parseStringLevels(snapshot.asks),
+      ts: snapshot.E ?? Date.now()
+    });
+    this.symbolStates.set(symbol, { phase: "syncing", lastUpdateId });
+    for (const event of buffered) {
+      if (!this.processEvent(symbol, event)) {
+        this.rebootstrap(symbol);
+        return;
+      }
+    }
+  }
+  processEvent(symbol, payload) {
+    const state = this.symbolStates.get(symbol);
+    if (!state) return false;
+    if (state.phase === "syncing") {
+      if (payload.u < state.lastUpdateId) return true;
+      if (!(payload.U <= state.lastUpdateId && payload.u >= state.lastUpdateId)) {
+        return false;
+      }
+      this.symbolStates.set(symbol, { phase: "ready", lastFinalUpdateId: payload.u });
+      this.emitDelta(symbol, payload);
+      return true;
+    }
+    if (state.phase === "ready") {
+      if (payload.pu !== state.lastFinalUpdateId) {
+        return false;
+      }
+      state.lastFinalUpdateId = payload.u;
+      this.emitDelta(symbol, payload);
+      return true;
+    }
+    return true;
+  }
+  emitDelta(symbol, payload) {
+    this.onUpdate({
+      symbol,
+      type: "delta",
+      bids: parseStringLevels(payload.b),
+      asks: parseStringLevels(payload.a),
+      ts: payload.E ?? Date.now(),
+      firstUpdateId: payload.U,
+      finalUpdateId: payload.u,
+      prevFinalUpdateId: payload.pu
+    });
+  }
+  rebootstrap(symbol) {
+    if (!this.symbolStates.has(symbol)) return;
+    this.symbolStates.set(symbol, { phase: "buffering", buffer: [] });
+    setTimeout(() => this.bootstrap(symbol), 1e3);
+  }
+  parseMessage(data) {
+    let msg;
+    try {
+      msg = JSON.parse(data);
+    } catch {
+      return null;
+    }
+    if (msg.e !== "depthUpdate") return null;
+    const payload = msg;
+    if (!payload.s || !Array.isArray(payload.b) || !Array.isArray(payload.a)) return null;
+    const state = this.symbolStates.get(payload.s);
+    if (!state) return null;
+    if (state.phase === "buffering") {
+      state.buffer.push(payload);
+      return null;
+    }
+    if (!this.processEvent(payload.s, payload)) {
+      this.rebootstrap(payload.s);
+    }
+    return null;
+  }
+}
+
+export { BinanceDepthWs };

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

@@ -0,0 +1,15 @@
+import { WsMessage } from '../../shared/types.js';
+import { DepthUpdate } from '../types.js';
+import { BaseDepthWs } from './base-depth.js';
+import '../../transport/index.js';
+import '@pear-protocol/types';
+import '../../transport/base-transport.js';
+import 'partysocket';
+
+declare class BybitDepthWs extends BaseDepthWs {
+    protected buildSubscribeMessage(symbol: string): WsMessage;
+    protected buildUnsubscribeMessage(symbol: string): WsMessage;
+    protected parseMessage(data: string): DepthUpdate | null;
+}
+
+export { BybitDepthWs };

package/dist/orderbook/ws/bybit.js

@@ -0,0 +1,40 @@
+import { BaseDepthWs, parseStringLevels } from './base-depth';
+
+const toTopic = (symbol) => `orderbook.1000.${symbol}`;
+const fromTopic = (topic) => {
+  const parts = topic.split(".");
+  return parts[2] ?? "";
+};
+class BybitDepthWs extends BaseDepthWs {
+  buildSubscribeMessage(symbol) {
+    return { op: "subscribe", args: [toTopic(symbol)] };
+  }
+  buildUnsubscribeMessage(symbol) {
+    return { op: "unsubscribe", args: [toTopic(symbol)] };
+  }
+  parseMessage(data) {
+    let msg;
+    try {
+      msg = JSON.parse(data);
+    } catch {
+      return null;
+    }
+    const topic = msg.topic;
+    const type = msg.type;
+    const payload = msg.data;
+    const ts = msg.ts ?? Date.now();
+    if (!topic || !topic.startsWith("orderbook.")) return null;
+    if (!payload) return null;
+    if (type !== "snapshot" && type !== "delta") return null;
+    const symbol = payload.s ?? fromTopic(topic);
+    return {
+      symbol,
+      type,
+      bids: parseStringLevels(payload.b),
+      asks: parseStringLevels(payload.a),
+      ts
+    };
+  }
+}
+
+export { BybitDepthWs };

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

@@ -0,0 +1,20 @@
+import { WsMessage } from '../../shared/types.js';
+import { DepthUpdate } from '../types.js';
+import { BaseDepthWs } from './base-depth.js';
+import '../../transport/index.js';
+import '@pear-protocol/types';
+import '../../transport/base-transport.js';
+import 'partysocket';
+
+declare class HyperliquidDepthWs extends BaseDepthWs {
+    private aggregation;
+    private lastNSigFigs;
+    private lastMantissa;
+    get serverAggregated(): boolean;
+    onAggregationChange(aggregation: number): void;
+    protected buildSubscribeMessage(symbol: string): WsMessage;
+    protected buildUnsubscribeMessage(symbol: string): WsMessage;
+    protected parseMessage(data: string): DepthUpdate | null;
+}
+
+export { HyperliquidDepthWs };

package/dist/orderbook/ws/hyperliquid.js

@@ -0,0 +1,87 @@
+import { BaseDepthWs } from './base-depth';
+
+const parseLevels = (levels) => {
+  if (!levels) return [];
+  return levels.map((l) => [l.px, Number(l.sz)]);
+};
+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 };
+  const nSigFigs = rawSigFigs;
+  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 };
+}
+class HyperliquidDepthWs extends BaseDepthWs {
+  aggregation = 0;
+  lastNSigFigs;
+  lastMantissa;
+  get serverAggregated() {
+    return true;
+  }
+  onAggregationChange(aggregation) {
+    this.aggregation = aggregation;
+    if (this.transport.connected) {
+      for (const symbol of this.symbols) {
+        this.transport.send(this.buildUnsubscribeMessage(symbol));
+        this.transport.send(this.buildSubscribeMessage(symbol));
+      }
+    }
+  }
+  buildSubscribeMessage(symbol) {
+    const { nSigFigs, mantissa } = this.aggregation > 0 && this.snapshottedPrice > 0 ? computeSigFigs(this.aggregation, this.snapshottedPrice) : {};
+    this.lastNSigFigs = nSigFigs;
+    this.lastMantissa = mantissa;
+    const subscription = {
+      type: "l2Book",
+      coin: symbol
+    };
+    if (nSigFigs !== void 0) subscription.nSigFigs = nSigFigs;
+    if (mantissa !== void 0) subscription.mantissa = mantissa;
+    return {
+      method: "subscribe",
+      subscription
+    };
+  }
+  buildUnsubscribeMessage(symbol) {
+    const subscription = {
+      type: "l2Book",
+      coin: symbol
+    };
+    if (this.lastNSigFigs !== void 0) subscription.nSigFigs = this.lastNSigFigs;
+    if (this.lastMantissa !== void 0) subscription.mantissa = this.lastMantissa;
+    return {
+      method: "unsubscribe",
+      subscription
+    };
+  }
+  parseMessage(data) {
+    let msg;
+    try {
+      msg = JSON.parse(data);
+    } catch {
+      return null;
+    }
+    if (msg.channel !== "l2Book" || !msg.data) return null;
+    const payload = msg.data;
+    if (!payload.coin || !Array.isArray(payload.levels) || payload.levels.length < 2) return null;
+    return {
+      symbol: payload.coin,
+      type: "snapshot",
+      bids: parseLevels(payload.levels[0]),
+      asks: parseLevels(payload.levels[1]),
+      ts: payload.time ?? Date.now()
+    };
+  }
+}
+
+export { HyperliquidDepthWs };

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

@@ -0,0 +1,11 @@
+import { Connector } from '@pear-protocol/types';
+import { BaseTransport } from '../../transport/base-transport.js';
+import { DepthHandler, BaseDepthWs } from './base-depth.js';
+import 'partysocket';
+import '../../shared/types.js';
+import '../types.js';
+import '../../transport/index.js';
+
+declare function createDepthWs(transport: BaseTransport, connector: Connector, onUpdate: DepthHandler): BaseDepthWs;
+
+export { BaseDepthWs, DepthHandler, createDepthWs };

package/dist/orderbook/ws/index.js

@@ -0,0 +1,24 @@
+export { BaseDepthWs } from './base-depth';
+import { BinanceDepthWs } from './binance';
+import { BybitDepthWs } from './bybit';
+import { HyperliquidDepthWs } from './hyperliquid';
+import { OkxDepthWs } from './okx';
+
+function createDepthWs(transport, connector, onUpdate) {
+  switch (connector) {
+    case "hyperliquid":
+      return new HyperliquidDepthWs(transport, onUpdate);
+    case "binance":
+      return new BinanceDepthWs(transport, onUpdate);
+    case "bybit":
+      return new BybitDepthWs(transport, onUpdate);
+    case "okx":
+      return new OkxDepthWs(transport, onUpdate);
+    default: {
+      const _exhaustive = connector;
+      throw new Error(`Unsupported exchange: ${String(_exhaustive)}`);
+    }
+  }
+}
+
+export { createDepthWs };

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

@@ -0,0 +1,15 @@
+import { WsMessage } from '../../shared/types.js';
+import { DepthUpdate } from '../types.js';
+import { BaseDepthWs } from './base-depth.js';
+import '../../transport/index.js';
+import '@pear-protocol/types';
+import '../../transport/base-transport.js';
+import 'partysocket';
+
+declare class OkxDepthWs extends BaseDepthWs {
+    protected buildSubscribeMessage(symbol: string): WsMessage;
+    protected buildUnsubscribeMessage(symbol: string): WsMessage;
+    protected parseMessage(data: string): DepthUpdate | null;
+}
+
+export { OkxDepthWs };

package/dist/orderbook/ws/okx.js

@@ -0,0 +1,33 @@
+import { BaseDepthWs, parseStringLevels } from './base-depth';
+
+class OkxDepthWs extends BaseDepthWs {
+  buildSubscribeMessage(symbol) {
+    return { op: "subscribe", args: [{ channel: "books", instId: symbol }] };
+  }
+  buildUnsubscribeMessage(symbol) {
+    return { op: "unsubscribe", args: [{ channel: "books", instId: symbol }] };
+  }
+  parseMessage(data) {
+    if (data === "pong") return null;
+    let msg;
+    try {
+      msg = JSON.parse(data);
+    } catch {
+      return null;
+    }
+    if (!msg.arg || msg.arg.channel !== "books") return null;
+    if (!msg.data || !Array.isArray(msg.data) || msg.data.length === 0) return null;
+    const payload = msg.data[0];
+    if (!payload) return null;
+    const type = msg.action === "snapshot" ? "snapshot" : "delta";
+    return {
+      symbol: msg.arg.instId,
+      type,
+      bids: parseStringLevels(payload.bids),
+      asks: parseStringLevels(payload.asks),
+      ts: Number(payload.ts) || Date.now()
+    };
+  }
+}
+
+export { OkxDepthWs };

package/dist/shared/types.d.ts

@@ -0,0 +1,6 @@
+interface WsMessage {
+    [key: string]: unknown;
+}
+type MessageListener = (data: string) => void;
+
+export type { MessageListener, WsMessage };

package/dist/shared/types.js

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,28 @@
+import { Connector } from '@pear-protocol/types';
+import { WebSocket } from 'partysocket';
+import { WsMessage, MessageListener } from '../shared/types.js';
+
+declare abstract class BaseTransport {
+    abstract readonly connector: Connector;
+    protected ws: WebSocket | null;
+    protected pingTimer: ReturnType<typeof setInterval> | null;
+    private messageListeners;
+    private openListeners;
+    private nextListenerId;
+    protected abstract getWsUrl(): string;
+    protected abstract getPingIntervalMs(): number;
+    protected abstract buildPingMessage(): WsMessage | string | null;
+    connect(): void;
+    disconnect(): void;
+    get connected(): boolean;
+    send(msg: WsMessage | string): void;
+    addMessageListener(listener: MessageListener): string;
+    removeMessageListener(id: string): void;
+    addOpenListener(listener: () => void): string;
+    removeOpenListener(id: string): void;
+    destroy(): void;
+    private startPing;
+    private stopPing;
+}
+
+export { BaseTransport };

package/dist/transport/base-transport.js

@@ -0,0 +1,95 @@
+import { WebSocket } from 'partysocket';
+
+class BaseTransport {
+  ws = null;
+  pingTimer = null;
+  messageListeners = /* @__PURE__ */ new Map();
+  openListeners = /* @__PURE__ */ new Map();
+  nextListenerId = 0;
+  connect() {
+    if (this.ws) return;
+    const ws = new WebSocket(this.getWsUrl(), [], {
+      maxReconnectionDelay: 3e4,
+      minReconnectionDelay: 1e3,
+      reconnectionDelayGrowFactor: 2,
+      connectionTimeout: 1e4
+    });
+    ws.addEventListener("open", () => {
+      this.startPing();
+      for (const listener of this.openListeners.values()) {
+        try {
+          listener();
+        } catch (error) {
+          console.warn("Error in transport open listener", error);
+        }
+      }
+    });
+    ws.addEventListener("message", (event) => {
+      for (const listener of this.messageListeners.values()) {
+        try {
+          listener(event.data);
+        } catch (error) {
+          console.warn("Error in transport message listener", error);
+        }
+      }
+    });
+    ws.addEventListener("close", () => {
+      this.stopPing();
+    });
+    ws.addEventListener("error", () => {
+    });
+    this.ws = ws;
+  }
+  disconnect() {
+    this.stopPing();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  get connected() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+  send(msg) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(typeof msg === "string" ? msg : JSON.stringify(msg));
+    }
+  }
+  addMessageListener(listener) {
+    const id = String(++this.nextListenerId);
+    this.messageListeners.set(id, listener);
+    return id;
+  }
+  removeMessageListener(id) {
+    this.messageListeners.delete(id);
+  }
+  addOpenListener(listener) {
+    const id = String(++this.nextListenerId);
+    this.openListeners.set(id, listener);
+    return id;
+  }
+  removeOpenListener(id) {
+    this.openListeners.delete(id);
+  }
+  destroy() {
+    this.disconnect();
+    this.messageListeners.clear();
+    this.openListeners.clear();
+  }
+  startPing() {
+    this.stopPing();
+    const intervalMs = this.getPingIntervalMs();
+    if (intervalMs <= 0) return;
+    const pingMsg = this.buildPingMessage();
+    if (!pingMsg) return;
+    this.pingTimer = setInterval(() => this.send(pingMsg), intervalMs);
+  }
+  stopPing() {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+  }
+}
+
+export { BaseTransport };

package/dist/transport/binance.d.ts

@@ -0,0 +1,13 @@
+import { Connector } from '@pear-protocol/types';
+import { BaseTransport } from './base-transport.js';
+import 'partysocket';
+import '../shared/types.js';
+
+declare class BinanceTransport extends BaseTransport {
+    readonly connector: Connector;
+    protected getWsUrl(): string;
+    protected getPingIntervalMs(): number;
+    protected buildPingMessage(): null;
+}
+
+export { BinanceTransport };

package/dist/transport/binance.js

@@ -0,0 +1,16 @@
+import { BaseTransport } from './base-transport';
+
+class BinanceTransport extends BaseTransport {
+  connector = "binance";
+  getWsUrl() {
+    return "wss://fstream.binance.com/ws";
+  }
+  getPingIntervalMs() {
+    return 0;
+  }
+  buildPingMessage() {
+    return null;
+  }
+}
+
+export { BinanceTransport };

package/dist/transport/bybit.d.ts

@@ -0,0 +1,13 @@
+import { Connector } from '@pear-protocol/types';
+import { WsMessage } from '../shared/types.js';
+import { BaseTransport } from './base-transport.js';
+import 'partysocket';
+
+declare class BybitTransport extends BaseTransport {
+    readonly connector: Connector;
+    protected getWsUrl(): string;
+    protected getPingIntervalMs(): number;
+    protected buildPingMessage(): WsMessage;
+}
+
+export { BybitTransport };

package/dist/transport/bybit.js

@@ -0,0 +1,16 @@
+import { BaseTransport } from './base-transport';
+
+class BybitTransport extends BaseTransport {
+  connector = "bybit";
+  getWsUrl() {
+    return "wss://stream.bybit.com/v5/public/linear";
+  }
+  getPingIntervalMs() {
+    return 2e4;
+  }
+  buildPingMessage() {
+    return { op: "ping" };
+  }
+}
+
+export { BybitTransport };

package/dist/transport/hyperliquid.d.ts

@@ -0,0 +1,13 @@
+import { Connector } from '@pear-protocol/types';
+import { WsMessage } from '../shared/types.js';
+import { BaseTransport } from './base-transport.js';
+import 'partysocket';
+
+declare class HyperliquidTransport extends BaseTransport {
+    readonly connector: Connector;
+    protected getWsUrl(): string;
+    protected getPingIntervalMs(): number;
+    protected buildPingMessage(): WsMessage;
+}
+
+export { HyperliquidTransport };

package/dist/transport/hyperliquid.js

@@ -0,0 +1,16 @@
+import { BaseTransport } from './base-transport';
+
+class HyperliquidTransport extends BaseTransport {
+  connector = "hyperliquid";
+  getWsUrl() {
+    return "wss://api.hyperliquid.xyz/ws";
+  }
+  getPingIntervalMs() {
+    return 3e4;
+  }
+  buildPingMessage() {
+    return { method: "ping" };
+  }
+}
+
+export { HyperliquidTransport };

package/dist/transport/index.d.ts

@@ -0,0 +1,10 @@
+import { Connector } from '@pear-protocol/types';
+import { BaseTransport } from './base-transport.js';
+import 'partysocket';
+import '../shared/types.js';
+
+type Transport = BaseTransport;
+
+declare function CreateTransport(connector: Connector): Transport;
+
+export { BaseTransport, CreateTransport, type Transport };

package/dist/transport/index.js

@@ -0,0 +1,24 @@
+export { BaseTransport } from './base-transport';
+import { BinanceTransport } from './binance';
+import { BybitTransport } from './bybit';
+import { HyperliquidTransport } from './hyperliquid';
+import { OkxTransport } from './okx';
+
+function CreateTransport(connector) {
+  switch (connector) {
+    case "binance":
+      return new BinanceTransport();
+    case "bybit":
+      return new BybitTransport();
+    case "okx":
+      return new OkxTransport();
+    case "hyperliquid":
+      return new HyperliquidTransport();
+    default: {
+      const _exhaustive = connector;
+      throw new Error(`Unsupported connector: ${String(_exhaustive)}`);
+    }
+  }
+}
+
+export { CreateTransport };