lighter-sdk-client 0.2.22

package/dist/chunk-6M6GRSDD.cjs

@@ -0,0 +1,370 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/client/ws-client.ts
+var _reconnectingwebsocket = require('reconnecting-websocket'); var _reconnectingwebsocket2 = _interopRequireDefault(_reconnectingwebsocket);
+var WsClient = class {
+  constructor(config) {
+    this.ws = null;
+    this.subscriptions = /* @__PURE__ */ new Map();
+    this.isConnected = false;
+    this.config = {
+      reconnectInterval: 5e3,
+      maxReconnectAttempts: 5,
+      ...config
+    };
+    this.url = this.config.url || "wss://mainnet.zklighter.elliot.ai/stream";
+  }
+  async connect() {
+    if (this.ws && this.isConnected) {
+      return;
+    }
+    try {
+      const options = {
+        connectionTimeout: 1e4,
+        maxRetries: this.config.maxReconnectAttempts || 5,
+        maxReconnectionDelay: 3e4,
+        minReconnectionDelay: this.config.reconnectInterval || 5e3,
+        reconnectionDelayGrowFactor: 1.5,
+        minUptime: 5e3
+      };
+      this.ws = new (0, _reconnectingwebsocket2.default)(this.url, [], options);
+      this.setupOpenHandler(this.ws);
+      await this.waitForConnection(this.ws);
+      this.setupMessageHandler(this.ws);
+      this.setupCloseHandler(this.ws);
+    } catch (error) {
+      console.error("WebSocket connection error:", error);
+      throw error;
+    }
+  }
+  setupOpenHandler(ws) {
+    ws.addEventListener("open", () => {
+      this.isConnected = true;
+      _optionalChain([this, 'access', _ => _.config, 'access', _2 => _2.onOpen, 'optionalCall', _3 => _3()]);
+      this.resubscribeAll();
+    });
+  }
+  async waitForConnection(ws) {
+    return new Promise((resolve, reject) => {
+      const onOpen = () => {
+        cleanup();
+        resolve();
+      };
+      const onError = () => {
+        _optionalChain([this, 'access', _4 => _4.config, 'access', _5 => _5.onError, 'optionalCall', _6 => _6(new Error("WebSocket error"))]);
+        cleanup();
+        reject(new Error("WebSocket error"));
+      };
+      const cleanup = () => {
+        ws.removeEventListener("open", onOpen);
+        ws.removeEventListener("error", onError);
+      };
+      ws.addEventListener("open", onOpen);
+      ws.addEventListener("error", onError);
+    });
+  }
+  setupMessageHandler(ws) {
+    ws.addEventListener("message", (event) => {
+      try {
+        const message = JSON.parse(event.data);
+        _optionalChain([this, 'access', _7 => _7.config, 'access', _8 => _8.onMessage, 'optionalCall', _9 => _9(message)]);
+        this.handleSubscriptionMessage(message);
+      } catch (error) {
+      }
+    });
+  }
+  setupCloseHandler(ws) {
+    ws.addEventListener("close", () => {
+      this.isConnected = false;
+      _optionalChain([this, 'access', _10 => _10.config, 'access', _11 => _11.onClose, 'optionalCall', _12 => _12()]);
+    });
+  }
+  disconnect() {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.isConnected = false;
+  }
+  subscribe(subscription) {
+    if (!this.isConnected || !this.ws) {
+      throw new Error("WebSocket is not connected");
+    }
+    const message = {
+      type: "subscribe",
+      channel: subscription.channel
+    };
+    if (subscription.auth) {
+      message.auth = subscription.auth;
+    }
+    if (subscription.params) {
+      for (const [key, value] of Object.entries(subscription.params)) {
+        if (value !== void 0) {
+          message[key] = value;
+        }
+      }
+    }
+    const normalizedChannel = this.normalizeChannel(subscription.channel);
+    const storedSubscription = { ...subscription };
+    this.ws.send(JSON.stringify(message));
+    this.subscriptions.set(normalizedChannel, storedSubscription);
+  }
+  subscribeOrderBook(marketIndex, handler) {
+    this.subscribe({
+      channel: `order_book/${marketIndex}`,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeOrderBook(marketIndex) {
+    this.unsubscribe(`order_book/${marketIndex}`);
+  }
+  subscribeMarketStats(market, handler) {
+    const channel = `market_stats/${market}`;
+    this.subscribe({
+      channel,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeMarketStats(market) {
+    this.unsubscribe(`market_stats/${market}`);
+  }
+  subscribeSpotMarketStats(market, handler) {
+    const channel = `spot_market_stats/${market}`;
+    this.subscribe({
+      channel,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeSpotMarketStats(market) {
+    this.unsubscribe(`spot_market_stats/${market}`);
+  }
+  subscribeTrades(marketIndex, handler) {
+    this.subscribe({
+      channel: `trade/${marketIndex}`,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeTrades(marketIndex) {
+    this.unsubscribe(`trade/${marketIndex}`);
+  }
+  subscribeAccountAll(accountId, handler) {
+    this.subscribe({
+      channel: `account_all/${accountId}`,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeAccountAll(accountId) {
+    this.unsubscribe(`account_all/${accountId}`);
+  }
+  subscribeAccountMarket(marketId, accountId, auth, handler) {
+    this.subscribe({
+      channel: `account_market/${marketId}/${accountId}`,
+      auth,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeAccountMarket(marketId, accountId) {
+    this.unsubscribe(`account_market/${marketId}/${accountId}`);
+  }
+  subscribeUserStats(accountId, handler) {
+    this.subscribe({
+      channel: `user_stats/${accountId}`,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeUserStats(accountId) {
+    this.unsubscribe(`user_stats/${accountId}`);
+  }
+  subscribeAccountAllAssets(accountId, auth, handler) {
+    this.subscribe({
+      channel: `account_all_assets/${accountId}`,
+      auth,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeAccountAllAssets(accountId) {
+    this.unsubscribe(`account_all_assets/${accountId}`);
+  }
+  subscribeTransactions(handler) {
+    this.subscribe({
+      channel: "transaction",
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeTransactions() {
+    this.unsubscribe("transaction");
+  }
+  subscribeExecutedTransactions(handler) {
+    this.subscribe({
+      channel: "executed_transaction",
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeExecutedTransactions() {
+    this.unsubscribe("executed_transaction");
+  }
+  subscribeAccountTransactions(accountId, auth, handler) {
+    this.subscribe({
+      channel: `account_tx/${accountId}`,
+      auth,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeAccountTransactions(accountId) {
+    this.unsubscribe(`account_tx/${accountId}`);
+  }
+  subscribeAccountAllOrders(accountId, auth, handler) {
+    this.subscribe({
+      channel: `account_all_orders/${accountId}`,
+      auth,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeAccountAllOrders(accountId) {
+    this.unsubscribe(`account_all_orders/${accountId}`);
+  }
+  subscribeHeight(handler) {
+    this.subscribe({
+      channel: "height",
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeHeight() {
+    this.unsubscribe("height");
+  }
+  subscribePoolData(accountId, auth, handler) {
+    this.subscribe({
+      channel: `pool_data/${accountId}`,
+      auth,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribePoolData(accountId) {
+    this.unsubscribe(`pool_data/${accountId}`);
+  }
+  subscribePoolInfo(accountId, auth, handler) {
+    this.subscribe({
+      channel: `pool_info/${accountId}`,
+      auth,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribePoolInfo(accountId) {
+    this.unsubscribe(`pool_info/${accountId}`);
+  }
+  subscribeNotifications(accountId, auth, handler) {
+    this.subscribe({
+      channel: `notification/${accountId}`,
+      auth,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeNotifications(accountId) {
+    this.unsubscribe(`notification/${accountId}`);
+  }
+  subscribeAccountOrders(marketIndex, accountId, auth, handler) {
+    this.subscribe({
+      channel: `account_orders/${marketIndex}/${accountId}`,
+      auth,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeAccountOrders(marketIndex, accountId) {
+    this.unsubscribe(`account_orders/${marketIndex}/${accountId}`);
+  }
+  subscribeAccountAllTrades(accountId, auth, handler) {
+    this.subscribe({
+      channel: `account_all_trades/${accountId}`,
+      auth,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeAccountAllTrades(accountId) {
+    this.unsubscribe(`account_all_trades/${accountId}`);
+  }
+  subscribeAccountAllPositions(accountId, auth, handler) {
+    this.subscribe({
+      channel: `account_all_positions/${accountId}`,
+      auth,
+      handler,
+      parser: this.passthroughParser()
+    });
+  }
+  unsubscribeAccountAllPositions(accountId) {
+    this.unsubscribe(`account_all_positions/${accountId}`);
+  }
+  unsubscribe(channel) {
+    if (!this.isConnected || !this.ws) {
+      throw new Error("WebSocket is not connected");
+    }
+    const message = {
+      type: "unsubscribe",
+      channel
+    };
+    this.ws.send(JSON.stringify(message));
+    this.subscriptions.delete(this.normalizeChannel(channel));
+  }
+  send(message) {
+    if (!this.isConnected || !this.ws) {
+      throw new Error("WebSocket is not connected");
+    }
+    this.ws.send(JSON.stringify(message));
+  }
+  normalizeChannel(channel) {
+    return channel.replace(/:/g, "/");
+  }
+  passthroughParser() {
+    return (payload) => payload;
+  }
+  handleSubscriptionMessage(rawMessage) {
+    if (!rawMessage || typeof rawMessage !== "object") {
+      return;
+    }
+    const channelName = typeof rawMessage.channel === "string" ? rawMessage.channel : void 0;
+    if (!channelName) {
+      return;
+    }
+    const normalizedChannel = this.normalizeChannel(channelName);
+    const subscription = this.subscriptions.get(normalizedChannel);
+    if (!subscription || typeof subscription.handler !== "function") {
+      return;
+    }
+    try {
+      const parser = typeof subscription.parser === "function" ? subscription.parser : (payload) => payload;
+      const parsed = parser(rawMessage);
+      subscription.handler(parsed);
+    } catch (error) {
+      const normalizedError = error instanceof Error ? error : new Error(String(error));
+      _optionalChain([this, 'access', _13 => _13.config, 'access', _14 => _14.onError, 'optionalCall', _15 => _15(normalizedError)]);
+    }
+  }
+  resubscribeAll() {
+    const subscriptions = Array.from(this.subscriptions.values());
+    for (const subscription of subscriptions) {
+      this.subscribe(subscription);
+    }
+  }
+  getSubscriptions() {
+    return Array.from(this.subscriptions.values());
+  }
+};
+
+
+
+exports.WsClient = WsClient;