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

package/dist/chart/ws/okx.js

@@ -0,0 +1,60 @@
+import { BaseCandleWs } from './base-candle';
+
+const intervalMap = {
+  "1m": "1m",
+  "3m": "3m",
+  "5m": "5m",
+  "15m": "15m",
+  "30m": "30m",
+  "1h": "1H",
+  "2h": "2H",
+  "4h": "4H",
+  "8h": "8H",
+  "12h": "12H",
+  "1d": "1D",
+  "3d": "3D",
+  "1w": "1W",
+  "1M": "1M"
+};
+const toChannel = (interval) => `candle${intervalMap[interval]}`;
+class OkxCandleWs extends BaseCandleWs {
+  buildSubscribeMessage(symbol, interval) {
+    return {
+      op: "subscribe",
+      args: [{ channel: toChannel(interval), instId: symbol }]
+    };
+  }
+  buildUnsubscribeMessage(symbol, interval) {
+    return {
+      op: "unsubscribe",
+      args: [{ channel: toChannel(interval), instId: symbol }]
+    };
+  }
+  parseMessage(data) {
+    if (data === "pong") return null;
+    let msg;
+    try {
+      msg = JSON.parse(data);
+    } catch {
+      return null;
+    }
+    const arg = msg.arg;
+    const candleData = msg.data;
+    if (!arg || !candleData || !Array.isArray(candleData) || candleData.length === 0) return null;
+    if (!arg.channel.startsWith("candle")) return null;
+    const d = candleData[0];
+    return {
+      symbol: arg.instId,
+      candle: {
+        t: Number(d[0]),
+        T: Number(d[0]),
+        o: Number(d[1]),
+        h: Number(d[2]),
+        l: Number(d[3]),
+        c: Number(d[4])
+      }
+    };
+  }
+}
+
+export { OkxCandleWs };

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { Chart } from './chart/chart.js';
+export { Bar, CandleData, CandleInterval, ChartConfig, ChartType, RealtimeBarCallback, RealtimeCandleCallback, TokenSelection } from './chart/types.js';
+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 { BaseTransport } from './transport/base-transport.js';
+import '@pear-protocol/types';
+import 'partysocket';
+import './shared/types.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export { Chart } from './chart/chart';
+export { Orderbook } from './orderbook/orderbook';
+export { getAvailableAggregations } from './orderbook/utils';
+export { BaseTransport, CreateTransport } from './transport';

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

@@ -0,0 +1,26 @@
+import { OrderbookLevel } from '../types.js';
+import { LocalBook } from './local-book.js';
+import '../../transport/index.js';
+import '@pear-protocol/types';
+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
+ * bucket size. Bids round *down* to the bucket boundary and asks round *up*
+ * — this ensures that any given raw price lands in the correct side's bucket
+ * without overlap at exact boundaries.
+ *
+ * Uses BigNumber internally to avoid floating-point artifacts in bucket
+ * boundaries and size accumulation.
+ *
+ * @param bucketSize - The price increment to aggregate into (e.g. 0.1, 1, 10).
+ * @param depth - Number of aggregated levels to return per side.
+ */
+declare function aggregateBook(localBook: LocalBook, bucketSize: number, depth: number): {
+    bids: OrderbookLevel[];
+    asks: OrderbookLevel[];
+};
+
+export { aggregateBook };

package/dist/orderbook/book/aggregate.js

@@ -0,0 +1,38 @@
+import BigNumber from 'bignumber.js';
+
+function aggregateBook(localBook, bucketSize, depth) {
+  const bucket = new BigNumber(bucketSize);
+  if (!bucket.isFinite() || bucket.lte(0)) return { bids: [], asks: [] };
+  return {
+    bids: walk(localBook.sortedBids(), bucket, "bid", depth),
+    asks: walk(localBook.sortedAsks(), bucket, "ask", depth)
+  };
+}
+function walk(sorted, bucket, side, depth) {
+  const result = [];
+  let currentBoundary = null;
+  let currentSize = new BigNumber(0);
+  for (let i = 0; i < sorted.length; i++) {
+    const entry = sorted[i];
+    if (!entry) continue;
+    const [price, size] = entry;
+    if (size <= 0) continue;
+    const p = new BigNumber(price);
+    const boundary = side === "bid" ? p.div(bucket).integerValue(BigNumber.ROUND_FLOOR).times(bucket) : p.div(bucket).integerValue(BigNumber.ROUND_CEIL).times(bucket);
+    if (currentBoundary === null || !boundary.eq(currentBoundary)) {
+      if (currentBoundary !== null) {
+        result.push({ price: currentBoundary.toNumber(), size: currentSize.toNumber() });
+        if (result.length >= depth) return result;
+      }
+      currentBoundary = boundary;
+      currentSize = new BigNumber(0);
+    }
+    currentSize = currentSize.plus(size);
+  }
+  if (currentBoundary !== null && result.length < depth) {
+    result.push({ price: currentBoundary.toNumber(), size: currentSize.toNumber() });
+  }
+  return result;
+}
+
+export { aggregateBook };

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

@@ -0,0 +1,37 @@
+import { BBO } from '../types.js';
+import '../../transport/index.js';
+import '@pear-protocol/types';
+import '../../transport/base-transport.js';
+import 'partysocket';
+import '../../shared/types.js';
+
+type Level = readonly [price: string, size: number];
+declare class LocalBook {
+    private _bids;
+    private _asks;
+    lastUpdateTs: number;
+    isLoaded: boolean;
+    /** Replace all state with a full snapshot. */
+    applySnapshot(bids: [string, number][], asks: [string, number][], ts: number): void;
+    /** Incrementally apply level changes. size === 0 means remove. */
+    applyDelta(bids: [string, number][], asks: [string, number][], ts: number): void;
+    /** Full sorted bids, price-descending. */
+    sortedBids(): readonly Level[];
+    /** Full sorted asks, price-ascending. */
+    sortedAsks(): readonly Level[];
+    /** Top N bids, price-descending. */
+    topBids(n: number): readonly Level[];
+    /** Top N asks, price-ascending. */
+    topAsks(n: number): readonly Level[];
+    /** Best bid, best ask, spread, and spread percentage. */
+    bbo(): BBO;
+    /** Reset the book to its initial empty state. */
+    clear(): void;
+    /**
+     * Insert, update, or remove a level in a sorted array.
+     * @param dir -1 for descending (bids), 1 for ascending (asks)
+     */
+    private upsert;
+}
+
+export { type Level, LocalBook };

package/dist/orderbook/book/local-book.js

@@ -0,0 +1,90 @@
+import BigNumber from 'bignumber.js';
+
+class LocalBook {
+  _bids = [];
+  _asks = [];
+  lastUpdateTs = 0;
+  isLoaded = false;
+  /** Replace all state with a full snapshot. */
+  applySnapshot(bids, asks, ts) {
+    this._bids = bids.filter(([, s]) => s > 0).sort((a, b) => Number(b[0]) - Number(a[0]));
+    this._asks = asks.filter(([, s]) => s > 0).sort((a, b) => Number(a[0]) - Number(b[0]));
+    this.lastUpdateTs = ts;
+    this.isLoaded = true;
+  }
+  /** Incrementally apply level changes. size === 0 means remove. */
+  applyDelta(bids, asks, ts) {
+    for (const [price, size] of bids) {
+      this.upsert(this._bids, price, size, -1);
+    }
+    for (const [price, size] of asks) {
+      this.upsert(this._asks, price, size, 1);
+    }
+    this.lastUpdateTs = ts;
+  }
+  /** Full sorted bids, price-descending. */
+  sortedBids() {
+    return this._bids;
+  }
+  /** Full sorted asks, price-ascending. */
+  sortedAsks() {
+    return this._asks;
+  }
+  /** Top N bids, price-descending. */
+  topBids(n) {
+    return this._bids.slice(0, n);
+  }
+  /** Top N asks, price-ascending. */
+  topAsks(n) {
+    return this._asks.slice(0, n);
+  }
+  /** Best bid, best ask, spread, and spread percentage. */
+  bbo() {
+    const bestBid = this._bids[0] ? new BigNumber(this._bids[0][0]) : null;
+    const bestAsk = this._asks[0] ? new BigNumber(this._asks[0][0]) : null;
+    const spread = bestBid !== null && bestAsk !== null ? bestAsk.minus(bestBid) : null;
+    const midPrice = bestBid !== null && bestAsk !== null ? bestAsk.plus(bestBid).div(2) : null;
+    const spreadPct = spread !== null && midPrice !== null && !midPrice.isZero() ? spread.div(midPrice).times(100) : null;
+    return {
+      bestBid: bestBid?.toFixed() ?? null,
+      bestAsk: bestAsk?.toFixed() ?? null,
+      spread: spread?.toFixed() ?? null,
+      spreadPct: spreadPct?.toFixed() ?? null
+    };
+  }
+  /** Reset the book to its initial empty state. */
+  clear() {
+    this._bids = [];
+    this._asks = [];
+    this.lastUpdateTs = 0;
+    this.isLoaded = false;
+  }
+  /**
+   * Insert, update, or remove a level in a sorted array.
+   * @param dir -1 for descending (bids), 1 for ascending (asks)
+   */
+  upsert(levels, price, size, dir) {
+    const numPrice = Number(price);
+    let lo = 0;
+    let hi = levels.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      const cmp = (Number(levels[mid]?.[0]) - numPrice) * dir;
+      if (cmp < 0) lo = mid + 1;
+      else hi = mid;
+    }
+    if (lo < levels.length && levels[lo]?.[0] === price) {
+      if (size === 0) {
+        levels.splice(lo, 1);
+      } else {
+        levels[lo] = [price, size];
+      }
+      return;
+    }
+    if (size > 0) {
+      levels.splice(lo, 0, [price, size]);
+    }
+  }
+}
+
+export { LocalBook };

package/dist/orderbook/orderbook.d.ts

@@ -0,0 +1,48 @@
+import { OrderbookConfig, OrderbookCallback, OrderbookSnapshot, BBO } from './types.js';
+import '../transport/index.js';
+import '@pear-protocol/types';
+import '../transport/base-transport.js';
+import 'partysocket';
+import '../shared/types.js';
+
+/**
+ * Orderbook exposes an aggregated top-of-book view for a single symbol.
+ * The underlying transport is owned by the caller and must be destroyed
+ * separately after the Orderbook itself is destroyed.
+ */
+declare class Orderbook {
+    private depthWs;
+    private symbol;
+    private book;
+    private listener;
+    private aggregation;
+    private depth;
+    constructor(config: OrderbookConfig);
+    /**
+     * Subscribe to orderbook updates. Returns the symbol as the subscription ID.
+     */
+    subscribe(cb: OrderbookCallback): string;
+    /**
+     * Unsubscribe from orderbook updates.
+     */
+    unsubscribe(id: string): void;
+    /**
+     * Set the aggregation bucket size (e.g. 0.1, 1, 10, 100).
+     * Set to 0 to disable aggregation.
+     */
+    setAggregation(aggregation: number): void;
+    getAggregation(): number;
+    /**
+     * Update the snapshotted mid-price used for server-side aggregation params
+     * (e.g. Hyperliquid's nSigFigs/mantissa).
+     */
+    setSnapshottedPrice(price: number): void;
+    getSnapshot(): OrderbookSnapshot | null;
+    get bbo(): BBO;
+    destroy(): void;
+    private handleUpdate;
+    private buildSnapshot;
+    private dispatch;
+}
+
+export { Orderbook };

package/dist/orderbook/orderbook.js

@@ -0,0 +1,111 @@
+import { aggregateBook } from './book/aggregate';
+import { LocalBook } from './book/local-book';
+import { DEFAULT_DEPTH } from './types';
+import { createDepthWs } from './ws';
+
+class Orderbook {
+  depthWs;
+  symbol;
+  book = new LocalBook();
+  listener = null;
+  aggregation;
+  depth;
+  constructor(config) {
+    this.symbol = config.symbol;
+    this.aggregation = config.aggregation ?? 0;
+    this.depth = config.depth ?? DEFAULT_DEPTH;
+    this.depthWs = createDepthWs(config.transport, config.transport.connector, (update) => this.handleUpdate(update));
+    if (config.snapshottedPrice !== void 0) {
+      this.depthWs.setSnapshottedPrice(config.snapshottedPrice);
+    }
+    this.depthWs.start();
+    this.depthWs.subscribe(this.symbol);
+  }
+  /**
+   * Subscribe to orderbook updates. Returns the symbol as the subscription ID.
+   */
+  subscribe(cb) {
+    this.listener = cb;
+    return this.symbol;
+  }
+  /**
+   * Unsubscribe from orderbook updates.
+   */
+  unsubscribe(id) {
+    if (id !== this.symbol) throw new Error(`Subscription "${id}" not found`);
+    this.listener = null;
+  }
+  /**
+   * Set the aggregation bucket size (e.g. 0.1, 1, 10, 100).
+   * Set to 0 to disable aggregation.
+   */
+  setAggregation(aggregation) {
+    if (this.aggregation === aggregation) return;
+    this.aggregation = aggregation;
+    this.depthWs.onAggregationChange(aggregation);
+    if (this.book.isLoaded) {
+      this.dispatch(this.buildSnapshot());
+    }
+  }
+  getAggregation() {
+    return this.aggregation;
+  }
+  /**
+   * Update the snapshotted mid-price used for server-side aggregation params
+   * (e.g. Hyperliquid's nSigFigs/mantissa).
+   */
+  setSnapshottedPrice(price) {
+    this.depthWs.setSnapshottedPrice(price);
+  }
+  getSnapshot() {
+    if (!this.book.isLoaded) return null;
+    return this.buildSnapshot();
+  }
+  get bbo() {
+    if (!this.book.isLoaded) return { bestBid: null, bestAsk: null, spread: null, spreadPct: null };
+    return this.book.bbo();
+  }
+  destroy() {
+    this.depthWs.stop();
+    this.listener = null;
+  }
+  handleUpdate(update) {
+    if (update.symbol !== this.symbol) return;
+    if (update.type === "snapshot") {
+      this.book.applySnapshot(update.bids, update.asks, update.ts);
+    } else {
+      if (!this.book.isLoaded) return;
+      this.book.applyDelta(update.bids, update.asks, update.ts);
+    }
+    this.dispatch(this.buildSnapshot());
+  }
+  buildSnapshot() {
+    let bids;
+    let asks;
+    if (!this.depthWs.serverAggregated && this.aggregation > 0) {
+      const aggregated = aggregateBook(this.book, this.aggregation, this.depth);
+      bids = aggregated.bids;
+      asks = aggregated.asks;
+    } else {
+      bids = this.book.topBids(this.depth).map(([price, size]) => ({ price: Number(price), size }));
+      asks = this.book.topAsks(this.depth).map(([price, size]) => ({ price: Number(price), size }));
+    }
+    return {
+      symbol: this.symbol,
+      bids,
+      asks,
+      aggregation: this.aggregation,
+      ts: this.book.lastUpdateTs
+    };
+  }
+  dispatch(snapshot) {
+    if (!this.listener) return;
+    try {
+      this.listener(snapshot);
+    } catch (error) {
+      console.warn("Error in orderbook stream callback", error);
+    }
+  }
+}
+
+export { Orderbook };

package/dist/orderbook/types.d.ts

@@ -0,0 +1,67 @@
+import { Transport } from '../transport/index.js';
+import '@pear-protocol/types';
+import '../transport/base-transport.js';
+import 'partysocket';
+import '../shared/types.js';
+
+declare const DEFAULT_DEPTH = 10;
+declare const DEFAULT_MULTIPLIERS: number[];
+type SigFigs = 2 | 3 | 4 | 5 | null;
+interface HyperliquidAggregationConfig {
+    maxDecimals: number;
+    midPrice: number;
+}
+interface CexAggregationConfig {
+    tickSize: number;
+    midPrice: number;
+}
+type AggregationConfig = HyperliquidAggregationConfig | CexAggregationConfig;
+interface OrderbookConfig {
+    transport: Transport;
+    /** The symbol to subscribe to. */
+    symbol: string;
+    /** Bucket size for price aggregation (e.g. 0.1, 1, 10, 100). Default: no aggregation. */
+    aggregation?: number;
+    /** Number of price levels per side in snapshots. Default: 10. */
+    depth?: number;
+    /** Snapshotted price, used for server-side aggregation params & deciding the aggregation options. */
+    snapshottedPrice?: number;
+}
+interface OrderbookLevel {
+    price: number;
+    /** Base-asset units. */
+    size: number;
+}
+interface OrderbookSnapshot {
+    symbol: string;
+    /** Price-descending. */
+    bids: OrderbookLevel[];
+    /** Price-ascending. */
+    asks: OrderbookLevel[];
+    /** Active bucket size for aggregation. */
+    aggregation: number;
+    /** ms since epoch of the last applied update. */
+    ts: number;
+}
+interface BBO {
+    bestBid: string | null;
+    bestAsk: string | null;
+    spread: string | null;
+    spreadPct: string | null;
+}
+type OrderbookCallback = (snapshot: OrderbookSnapshot) => void;
+interface DepthUpdate {
+    symbol: string;
+    type: 'snapshot' | 'delta';
+    bids: [price: string, size: number][];
+    asks: [price: string, size: number][];
+    ts: number;
+    /** Binance diff stream: first update ID in this event. */
+    firstUpdateId?: number;
+    /** Binance diff stream: final update ID in this event. */
+    finalUpdateId?: number;
+    /** Binance diff stream: previous event's final update ID. */
+    prevFinalUpdateId?: number;
+}
+
+export { type AggregationConfig, type BBO, type CexAggregationConfig, DEFAULT_DEPTH, DEFAULT_MULTIPLIERS, type DepthUpdate, type HyperliquidAggregationConfig, type OrderbookCallback, type OrderbookConfig, type OrderbookLevel, type OrderbookSnapshot, type SigFigs };

package/dist/orderbook/types.js

@@ -0,0 +1,4 @@
+const DEFAULT_DEPTH = 10;
+const DEFAULT_MULTIPLIERS = [1, 10, 100, 1e3, 1e4];
+
+export { DEFAULT_DEPTH, DEFAULT_MULTIPLIERS };

package/dist/orderbook/utils.d.ts

@@ -0,0 +1,12 @@
+import { Connector } from '@pear-protocol/types';
+import { AggregationConfig } from './types.js';
+import '../transport/index.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[];
+declare function getAvailableAggregations(connector: Connector, config: AggregationConfig, multipliers?: number[]): number[];
+
+export { getAvailableAggregations, getCexAvailableAggregations, getHyperliquidAvailableAggregations };

package/dist/orderbook/utils.js

@@ -0,0 +1,35 @@
+import BigNumber from 'bignumber.js';
+import { DEFAULT_MULTIPLIERS } from './types';
+
+function getCexAvailableAggregations(tickSize, midPrice, multipliers = DEFAULT_MULTIPLIERS) {
+  if (tickSize <= 0 || midPrice <= 0) return [];
+  const tick = new BigNumber(tickSize);
+  const priceMag = Math.floor(Math.log10(midPrice));
+  const maxBucketMag = priceMag - 1;
+  return multipliers.map((m) => tick.times(m).toNumber()).filter((bucket) => {
+    const bucketMag = Math.floor(Math.log10(bucket));
+    return bucket < midPrice && bucketMag <= maxBucketMag;
+  });
+}
+function getHyperliquidAvailableAggregations(maxDecimals, midPrice, multipliers = DEFAULT_MULTIPLIERS) {
+  if (midPrice <= 0) return [];
+  const decimals = Math.max(0, maxDecimals);
+  const baseBucket = new BigNumber(10).pow(-decimals);
+  const priceMag = Math.floor(Math.log10(midPrice));
+  const minBucketMag = priceMag - 4;
+  const maxBucketMag = priceMag - 1;
+  return multipliers.map((m) => baseBucket.times(m).toNumber()).filter((bucket) => {
+    const bucketMag = Math.floor(Math.log10(bucket));
+    return bucket < midPrice && bucketMag >= minBucketMag && bucketMag <= maxBucketMag;
+  });
+}
+function getAvailableAggregations(connector, config, multipliers = DEFAULT_MULTIPLIERS) {
+  if (connector === "hyperliquid") {
+    const { maxDecimals, midPrice: midPrice2 } = config;
+    return getHyperliquidAvailableAggregations(maxDecimals, midPrice2, multipliers);
+  }
+  const { tickSize, midPrice } = config;
+  return getCexAvailableAggregations(tickSize, midPrice, multipliers);
+}
+
+export { getAvailableAggregations, getCexAvailableAggregations, getHyperliquidAvailableAggregations };

package/dist/orderbook/ws/base-depth.d.ts

@@ -0,0 +1,41 @@
+import { WsMessage } from '../../shared/types.js';
+import { BaseTransport } from '../../transport/base-transport.js';
+import { DepthUpdate } from '../types.js';
+import '@pear-protocol/types';
+import 'partysocket';
+import '../../transport/index.js';
+
+type DepthHandler = (update: DepthUpdate) => void;
+/**
+ * Convert string-encoded L2 levels into numeric tuples. Accepts any tuple
+ * arity where the first two slots are `[price, size]` — exchanges sometimes
+ * pad trailing metadata (OKX adds liquidated-order counts, for example) that
+ * the book layer ignores.
+ */
+declare function parseStringLevels(levels: ReadonlyArray<ReadonlyArray<string>> | undefined): [string, number][];
+declare abstract class BaseDepthWs {
+    protected transport: BaseTransport;
+    protected onUpdate: DepthHandler;
+    protected snapshottedPrice: number;
+    private messageListenerId;
+    private openListenerId;
+    private subscribedSymbols;
+    protected abstract buildSubscribeMessage(symbol: string): WsMessage;
+    protected abstract buildUnsubscribeMessage(symbol: string): WsMessage;
+    protected abstract parseMessage(data: string): DepthUpdate | null;
+    constructor(transport: BaseTransport, onUpdate: DepthHandler);
+    start(): void;
+    stop(): void;
+    get connected(): boolean;
+    subscribe(symbol: string): void;
+    unsubscribe(symbol: string): void;
+    /** Whether this adapter handles aggregation server-side. */
+    get serverAggregated(): boolean;
+    /** Called when aggregation changes. Override to resubscribe with new params. */
+    onAggregationChange(_aggregation: number): void;
+    /** Update the snapshotted mid-price used for server-side aggregation params. */
+    setSnapshottedPrice(price: number): void;
+    protected get symbols(): ReadonlySet<string>;
+}
+
+export { BaseDepthWs, type DepthHandler, parseStringLevels };

package/dist/orderbook/ws/base-depth.js

@@ -0,0 +1,89 @@
+function parseStringLevels(levels) {
+  if (!levels) return [];
+  const out = new Array(levels.length);
+  for (let i = 0; i < levels.length; i++) {
+    const entry = levels[i];
+    if (!entry) continue;
+    out[i] = [entry[0], Number(entry[1])];
+  }
+  return out;
+}
+class BaseDepthWs {
+  transport;
+  onUpdate;
+  snapshottedPrice = 0;
+  messageListenerId = null;
+  openListenerId = null;
+  subscribedSymbols = /* @__PURE__ */ new Set();
+  constructor(transport, onUpdate) {
+    this.transport = transport;
+    this.onUpdate = onUpdate;
+  }
+  start() {
+    if (this.messageListenerId) return;
+    this.messageListenerId = this.transport.addMessageListener((data) => {
+      const update = this.parseMessage(data);
+      if (update) this.onUpdate(update);
+    });
+    this.openListenerId = this.transport.addOpenListener(() => {
+      for (const symbol of this.subscribedSymbols) {
+        this.transport.send(this.buildSubscribeMessage(symbol));
+      }
+    });
+    if (!this.transport.connected) {
+      this.transport.connect();
+    }
+    if (this.transport.connected) {
+      for (const symbol of this.subscribedSymbols) {
+        this.transport.send(this.buildSubscribeMessage(symbol));
+      }
+    }
+  }
+  stop() {
+    if (this.messageListenerId) {
+      this.transport.removeMessageListener(this.messageListenerId);
+      this.messageListenerId = null;
+    }
+    if (this.openListenerId) {
+      this.transport.removeOpenListener(this.openListenerId);
+      this.openListenerId = null;
+    }
+    for (const symbol of this.subscribedSymbols) {
+      this.transport.send(this.buildUnsubscribeMessage(symbol));
+    }
+    this.subscribedSymbols.clear();
+  }
+  get connected() {
+    return this.transport.connected;
+  }
+  subscribe(symbol) {
+    if (this.subscribedSymbols.has(symbol)) return;
+    this.subscribedSymbols.add(symbol);
+    if (this.transport.connected) {
+      this.transport.send(this.buildSubscribeMessage(symbol));
+    }
+  }
+  unsubscribe(symbol) {
+    if (!this.subscribedSymbols.has(symbol)) return;
+    this.subscribedSymbols.delete(symbol);
+    if (this.transport.connected) {
+      this.transport.send(this.buildUnsubscribeMessage(symbol));
+    }
+  }
+  /** Whether this adapter handles aggregation server-side. */
+  get serverAggregated() {
+    return false;
+  }
+  /** Called when aggregation changes. Override to resubscribe with new params. */
+  onAggregationChange(_aggregation) {
+  }
+  /** Update the snapshotted mid-price used for server-side aggregation params. */
+  setSnapshottedPrice(price) {
+    this.snapshottedPrice = price;
+  }
+  get symbols() {
+    return this.subscribedSymbols;
+  }
+}
+
+export { BaseDepthWs, parseStringLevels };