@alango/dr-manhattan 0.1.0 → 0.1.2

package/README.md

@@ -183,8 +183,7 @@ await ws.disconnect();
 #### Limitless WebSocket
 
 ```typescript
-import { Limitless } from '@alango/dr-manhattan';
-import { LimitlessWebSocket } from '@alango/dr-manhattan/exchanges/limitless';
+import { LimitlessWebSocket } from '@alango/dr-manhattan';
 
 const ws = new LimitlessWebSocket();
 

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { EventEmitter } from 'node:events';
 import WebSocket from 'ws';
 import pino from 'pino';
+import { Socket } from 'socket.io-client';
 
 /**
  * Order-related types for prediction market trading.
@@ -611,6 +612,73 @@ declare class Opinion extends Exchange {
     };
 }
 
+interface LimitlessWsConfig {
+    verbose?: boolean;
+    sessionCookie?: string;
+    autoReconnect?: boolean;
+    reconnectDelay?: number;
+    maxReconnectAttempts?: number;
+}
+interface LimitlessOrderbookUpdate {
+    slug: string;
+    bids: [number, number][];
+    asks: [number, number][];
+    timestamp: Date;
+}
+interface LimitlessPriceUpdate {
+    marketAddress: string;
+    yesPrice: number;
+    noPrice: number;
+    blockNumber: number;
+    timestamp: Date;
+}
+interface LimitlessPositionUpdate {
+    account: string;
+    marketAddress: string;
+    tokenId: string;
+    balance: number;
+    outcomeIndex: number;
+    marketType: 'AMM' | 'CLOB';
+}
+type OrderbookUpdateCallback = (update: LimitlessOrderbookUpdate) => void | Promise<void>;
+type PriceUpdateCallback = (update: LimitlessPriceUpdate) => void | Promise<void>;
+type PositionUpdateCallback = (update: LimitlessPositionUpdate) => void | Promise<void>;
+type ErrorCallback = (error: string) => void;
+declare class LimitlessWebSocket extends EventEmitter {
+    protected config: LimitlessWsConfig;
+    protected socket: Socket | null;
+    protected state: WebSocketState;
+    protected reconnectAttempts: number;
+    protected subscribedSlugs: string[];
+    protected subscribedAddresses: string[];
+    protected orderbookCallbacks: OrderbookUpdateCallback[];
+    protected priceCallbacks: PriceUpdateCallback[];
+    protected positionCallbacks: PositionUpdateCallback[];
+    protected errorCallbacks: ErrorCallback[];
+    readonly orderbookManager: OrderbookManager;
+    protected tokenToSlug: Map<string, string>;
+    constructor(config?: LimitlessWsConfig);
+    get isConnected(): boolean;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    protected setupEventHandlers(): void;
+    protected parseOrderbookUpdate(data: Record<string, unknown>): LimitlessOrderbookUpdate | null;
+    protected parsePriceUpdate(data: Record<string, unknown>): LimitlessPriceUpdate | null;
+    protected parsePositionUpdates(data: Record<string, unknown>): LimitlessPositionUpdate[];
+    protected resubscribe(): Promise<void>;
+    protected sendSubscription(): Promise<void>;
+    subscribeMarket(marketSlug: string): Promise<void>;
+    subscribeMarketAddress(marketAddress: string): Promise<void>;
+    unsubscribeMarket(marketSlug: string): Promise<void>;
+    unsubscribeMarketAddress(marketAddress: string): Promise<void>;
+    onOrderbook(callback: OrderbookUpdateCallback): this;
+    onPrice(callback: PriceUpdateCallback): this;
+    onPosition(callback: PositionUpdateCallback): this;
+    onError(callback: ErrorCallback): this;
+    watchOrderbookByMarket(marketSlug: string, assetIds: string[], callback?: OrderbookCallback): Promise<void>;
+    getOrderbookManager(): OrderbookManager;
+}
+
 interface LimitlessConfig extends ExchangeConfig {
     host?: string;
     chainId?: number;
@@ -693,4 +761,4 @@ declare function clampPrice(price: number, min?: number, max?: number): number;
 declare function formatPrice(price: number, decimals?: number): string;
 declare function formatUsd(amount: number): string;
 
-export { AuthenticationError, Colors, type CreateOrderParams, type DeltaInfo, DrManhattanError, Exchange, type ExchangeCapabilities, type ExchangeConfig, ExchangeError, type FetchMarketsParams, InsufficientFunds, InvalidOrder, Limitless, type Market, MarketNotFound, MarketUtils, NetworkError, Opinion, type Order, OrderBookWebSocket, OrderSide, OrderStatus, OrderUtils, type Orderbook, type OrderbookCallback, OrderbookManager, type OrderbookUpdate, OrderbookUtils, type OutcomeToken, Polymarket, PolymarketWebSocket, type Position, PositionUtils, type PriceLevel, RateLimitError, Strategy, type StrategyConfig, StrategyState, type WebSocketConfig, WebSocketState, calculateDelta, clampPrice, createExchange, createLogger, formatPrice, formatUsd, listExchanges, logger, roundToTickSize };
+export { AuthenticationError, Colors, type CreateOrderParams, type DeltaInfo, DrManhattanError, Exchange, type ExchangeCapabilities, type ExchangeConfig, ExchangeError, type FetchMarketsParams, InsufficientFunds, InvalidOrder, Limitless, LimitlessWebSocket, type Market, MarketNotFound, MarketUtils, NetworkError, Opinion, type Order, OrderBookWebSocket, OrderSide, OrderStatus, OrderUtils, type Orderbook, type OrderbookCallback, OrderbookManager, type OrderbookUpdate, OrderbookUtils, type OutcomeToken, Polymarket, PolymarketWebSocket, type Position, PositionUtils, type PriceLevel, RateLimitError, Strategy, type StrategyConfig, StrategyState, type WebSocketConfig, WebSocketState, calculateDelta, clampPrice, createExchange, createLogger, formatPrice, formatUsd, listExchanges, logger, roundToTickSize };

package/dist/index.js

@@ -1,7 +1,7 @@
 import { EventEmitter } from 'events';
 import WebSocket from 'ws';
 import { Wallet } from 'ethers';
-import 'socket.io-client';
+import { io } from 'socket.io-client';
 import { ClobClient, Side, AssetType } from '@polymarket/clob-client';
 import pino from 'pino';
 
@@ -702,6 +702,347 @@ var Strategy = class extends EventEmitter {
     return this.state;
   }
 };
+var WS_URL = "wss://ws.limitless.exchange";
+var NAMESPACE = "/markets";
+var LimitlessWebSocket = class extends EventEmitter {
+  config;
+  socket = null;
+  state = WebSocketState.DISCONNECTED;
+  reconnectAttempts = 0;
+  subscribedSlugs = [];
+  subscribedAddresses = [];
+  orderbookCallbacks = [];
+  priceCallbacks = [];
+  positionCallbacks = [];
+  errorCallbacks = [];
+  orderbookManager = new OrderbookManager();
+  tokenToSlug = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    super();
+    this.config = {
+      verbose: false,
+      autoReconnect: true,
+      reconnectDelay: 1e3,
+      maxReconnectAttempts: 999,
+      ...config
+    };
+  }
+  get isConnected() {
+    return this.state === WebSocketState.CONNECTED && !!this.socket?.connected;
+  }
+  async connect() {
+    if (this.state === WebSocketState.CONNECTED) return;
+    this.state = WebSocketState.CONNECTING;
+    return new Promise((resolve, reject) => {
+      const extraHeaders = {};
+      if (this.config.sessionCookie) {
+        extraHeaders.Cookie = `limitless_session=${this.config.sessionCookie}`;
+      }
+      this.socket = io(`${WS_URL}${NAMESPACE}`, {
+        transports: ["websocket"],
+        reconnection: this.config.autoReconnect,
+        reconnectionAttempts: this.config.maxReconnectAttempts,
+        reconnectionDelay: this.config.reconnectDelay,
+        reconnectionDelayMax: 3e4,
+        extraHeaders
+      });
+      this.setupEventHandlers();
+      const connectTimeout = setTimeout(() => {
+        reject(new Error("Connection timeout"));
+      }, 1e4);
+      this.socket.on("connect", () => {
+        clearTimeout(connectTimeout);
+        this.state = WebSocketState.CONNECTED;
+        this.reconnectAttempts = 0;
+        if (this.config.verbose) {
+          console.log("Connected to Limitless WebSocket");
+        }
+        this.resubscribe().then(resolve).catch(reject);
+      });
+      this.socket.on("connect_error", (err) => {
+        clearTimeout(connectTimeout);
+        if (this.state === WebSocketState.CONNECTING) {
+          reject(err);
+        }
+      });
+    });
+  }
+  async disconnect() {
+    this.state = WebSocketState.CLOSED;
+    if (this.socket) {
+      this.socket.disconnect();
+      this.socket = null;
+    }
+  }
+  setupEventHandlers() {
+    if (!this.socket) return;
+    this.socket.on("disconnect", () => {
+      this.state = WebSocketState.DISCONNECTED;
+      if (this.config.verbose) {
+        console.log("Disconnected from Limitless WebSocket");
+      }
+    });
+    this.socket.on("orderbookUpdate", (data) => {
+      try {
+        const update = this.parseOrderbookUpdate(data);
+        if (update) {
+          for (const callback of this.orderbookCallbacks) {
+            Promise.resolve(callback(update)).catch((e) => {
+              if (this.config.verbose) console.error("Orderbook callback error:", e);
+            });
+          }
+        }
+      } catch (e) {
+        if (this.config.verbose) console.error("Error parsing orderbook update:", e);
+      }
+    });
+    this.socket.on("newPriceData", (data) => {
+      try {
+        const update = this.parsePriceUpdate(data);
+        if (update) {
+          for (const callback of this.priceCallbacks) {
+            Promise.resolve(callback(update)).catch((e) => {
+              if (this.config.verbose) console.error("Price callback error:", e);
+            });
+          }
+        }
+      } catch (e) {
+        if (this.config.verbose) console.error("Error parsing price update:", e);
+      }
+    });
+    this.socket.on("positions", (data) => {
+      try {
+        const updates = this.parsePositionUpdates(data);
+        for (const update of updates) {
+          for (const callback of this.positionCallbacks) {
+            Promise.resolve(callback(update)).catch((e) => {
+              if (this.config.verbose) console.error("Position callback error:", e);
+            });
+          }
+        }
+      } catch (e) {
+        if (this.config.verbose) console.error("Error parsing position update:", e);
+      }
+    });
+    this.socket.on("authenticated", () => {
+      if (this.config.verbose) {
+        console.log("Authenticated with Limitless WebSocket");
+      }
+    });
+    this.socket.on("exception", (data) => {
+      const errorMsg = String(data);
+      if (this.config.verbose) {
+        console.error("WebSocket exception:", errorMsg);
+      }
+      for (const callback of this.errorCallbacks) {
+        callback(errorMsg);
+      }
+    });
+    this.socket.on("system", (data) => {
+      if (this.config.verbose) {
+        console.log("System message:", data);
+      }
+    });
+  }
+  parseOrderbookUpdate(data) {
+    const slug = data.marketSlug ?? data.slug ?? "";
+    if (!slug) return null;
+    const orderbookData = data.orderbook ?? data;
+    const bids = [];
+    const rawBids = orderbookData.bids;
+    if (rawBids) {
+      for (const bid of rawBids) {
+        const price = Number(bid.price ?? 0);
+        const size = Number(bid.size ?? 0);
+        if (price > 0) {
+          bids.push([price, size]);
+        }
+      }
+    }
+    const asks = [];
+    const rawAsks = orderbookData.asks;
+    if (rawAsks) {
+      for (const ask of rawAsks) {
+        const price = Number(ask.price ?? 0);
+        const size = Number(ask.size ?? 0);
+        if (price > 0) {
+          asks.push([price, size]);
+        }
+      }
+    }
+    bids.sort((a, b) => b[0] - a[0]);
+    asks.sort((a, b) => a[0] - b[0]);
+    let timestamp;
+    const ts = data.timestamp;
+    if (typeof ts === "string") {
+      timestamp = new Date(ts);
+    } else if (typeof ts === "number") {
+      timestamp = new Date(ts > 1e12 ? ts : ts * 1e3);
+    } else {
+      timestamp = /* @__PURE__ */ new Date();
+    }
+    return { slug, bids, asks, timestamp };
+  }
+  parsePriceUpdate(data) {
+    const marketAddress = data.marketAddress ?? "";
+    if (!marketAddress) return null;
+    const prices = data.updatedPrices ?? {};
+    const yesPrice = Number(prices.yes ?? 0);
+    const noPrice = Number(prices.no ?? 0);
+    const blockNumber = Number(data.blockNumber ?? 0);
+    let timestamp;
+    const ts = data.timestamp;
+    if (typeof ts === "string") {
+      timestamp = new Date(ts);
+    } else {
+      timestamp = /* @__PURE__ */ new Date();
+    }
+    return { marketAddress, yesPrice, noPrice, blockNumber, timestamp };
+  }
+  parsePositionUpdates(data) {
+    const updates = [];
+    const account = data.account ?? "";
+    const marketAddress = data.marketAddress ?? "";
+    const marketType = data.type ?? "CLOB";
+    const positions = data.positions ?? [];
+    for (const pos of positions) {
+      updates.push({
+        account,
+        marketAddress,
+        tokenId: String(pos.tokenId ?? ""),
+        balance: Number(pos.balance ?? 0),
+        outcomeIndex: Number(pos.outcomeIndex ?? 0),
+        marketType
+      });
+    }
+    return updates;
+  }
+  async resubscribe() {
+    if (this.subscribedSlugs.length > 0 || this.subscribedAddresses.length > 0) {
+      await this.sendSubscription();
+    }
+  }
+  async sendSubscription() {
+    if (!this.socket?.connected) return;
+    const payload = {};
+    if (this.subscribedAddresses.length > 0) {
+      payload.marketAddresses = this.subscribedAddresses;
+    }
+    if (this.subscribedSlugs.length > 0) {
+      payload.marketSlugs = this.subscribedSlugs;
+    }
+    if (Object.keys(payload).length > 0) {
+      this.socket.emit("subscribe_market_prices", payload);
+      if (this.config.verbose) {
+        console.log("Subscribed to markets:", payload);
+      }
+    }
+  }
+  async subscribeMarket(marketSlug) {
+    if (!this.subscribedSlugs.includes(marketSlug)) {
+      this.subscribedSlugs.push(marketSlug);
+    }
+    if (this.isConnected) {
+      await this.sendSubscription();
+    }
+  }
+  async subscribeMarketAddress(marketAddress) {
+    if (!this.subscribedAddresses.includes(marketAddress)) {
+      this.subscribedAddresses.push(marketAddress);
+    }
+    if (this.isConnected) {
+      await this.sendSubscription();
+    }
+  }
+  async unsubscribeMarket(marketSlug) {
+    const index = this.subscribedSlugs.indexOf(marketSlug);
+    if (index !== -1) {
+      this.subscribedSlugs.splice(index, 1);
+    }
+    if (this.isConnected) {
+      await this.sendSubscription();
+    }
+  }
+  async unsubscribeMarketAddress(marketAddress) {
+    const index = this.subscribedAddresses.indexOf(marketAddress);
+    if (index !== -1) {
+      this.subscribedAddresses.splice(index, 1);
+    }
+    if (this.isConnected) {
+      await this.sendSubscription();
+    }
+  }
+  onOrderbook(callback) {
+    this.orderbookCallbacks.push(callback);
+    return this;
+  }
+  onPrice(callback) {
+    this.priceCallbacks.push(callback);
+    return this;
+  }
+  onPosition(callback) {
+    this.positionCallbacks.push(callback);
+    return this;
+  }
+  onError(callback) {
+    this.errorCallbacks.push(callback);
+    return this;
+  }
+  async watchOrderbookByMarket(marketSlug, assetIds, callback) {
+    for (const assetId of assetIds) {
+      this.tokenToSlug.set(assetId, marketSlug);
+    }
+    const yesToken = assetIds[0];
+    const noToken = assetIds[1];
+    const orderbookHandler = (update) => {
+      const ts = update.timestamp.getTime();
+      if (yesToken) {
+        this.orderbookManager.update(yesToken, {
+          bids: update.bids,
+          asks: update.asks,
+          timestamp: ts,
+          assetId: yesToken,
+          marketId: update.slug
+        });
+      }
+      if (noToken) {
+        const noBids = update.asks.map(([price, size]) => [
+          Math.round((1 - price) * 1e3) / 1e3,
+          size
+        ]);
+        const noAsks = update.bids.map(([price, size]) => [
+          Math.round((1 - price) * 1e3) / 1e3,
+          size
+        ]);
+        noBids.sort((a, b) => b[0] - a[0]);
+        noAsks.sort((a, b) => a[0] - b[0]);
+        this.orderbookManager.update(noToken, {
+          bids: noBids,
+          asks: noAsks,
+          timestamp: ts,
+          assetId: noToken,
+          marketId: update.slug
+        });
+      }
+      if (callback) {
+        callback(marketSlug, {
+          marketId: marketSlug,
+          bids: update.bids,
+          asks: update.asks,
+          timestamp: ts
+        });
+      }
+    };
+    this.onOrderbook(orderbookHandler);
+    if (!this.isConnected) {
+      await this.connect();
+    }
+    await this.subscribeMarket(marketSlug);
+  }
+  getOrderbookManager() {
+    return this.orderbookManager;
+  }
+};
 
 // src/exchanges/limitless/index.ts
 var BASE_URL = "https://api.limitless.exchange";
@@ -2392,9 +2733,9 @@ var Polymarket = class extends Exchange {
 };
 
 // src/exchanges/polymarket/polymarket-ws.ts
-var WS_URL = "wss://ws-subscriptions-clob.polymarket.com/ws/market";
+var WS_URL2 = "wss://ws-subscriptions-clob.polymarket.com/ws/market";
 var PolymarketWebSocket = class extends OrderBookWebSocket {
-  wsUrl = WS_URL;
+  wsUrl = WS_URL2;
   apiKey;
   assetSubscriptions = /* @__PURE__ */ new Map();
   constructor(config = {}) {
@@ -2532,6 +2873,6 @@ function formatUsd(amount) {
   return `$${amount.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
 }
 
-export { AuthenticationError, Colors, DrManhattanError, Exchange, ExchangeError, InsufficientFunds, InvalidOrder, Limitless, MarketNotFound, MarketUtils, NetworkError, Opinion, OrderBookWebSocket, OrderSide, OrderStatus, OrderUtils, OrderbookManager, OrderbookUtils, Polymarket, PolymarketWebSocket, PositionUtils, RateLimitError, Strategy, StrategyState, WebSocketState, calculateDelta, clampPrice, createExchange, createLogger, formatPrice, formatUsd, listExchanges, logger, roundToTickSize };
+export { AuthenticationError, Colors, DrManhattanError, Exchange, ExchangeError, InsufficientFunds, InvalidOrder, Limitless, LimitlessWebSocket, MarketNotFound, MarketUtils, NetworkError, Opinion, OrderBookWebSocket, OrderSide, OrderStatus, OrderUtils, OrderbookManager, OrderbookUtils, Polymarket, PolymarketWebSocket, PositionUtils, RateLimitError, Strategy, StrategyState, WebSocketState, calculateDelta, clampPrice, createExchange, createLogger, formatPrice, formatUsd, listExchanges, logger, roundToTickSize };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map