feat: improve promise handling, fix eslint

Author: tejasbadadare

lazer/sdk/js/examples/index.ts

@@ -1,3 +1,6 @@
+/* eslint-disable no-console */
+/* eslint-disable @typescript-eslint/no-empty-function */
+
 import { PythLazerClient } from "../src/index.js";
 
 // Ignore debug messages
@@ -37,7 +40,7 @@ client.addMessageListener((message) => {
 });
 
 // Create and remove one or more subscriptions on the fly
-client.subscribe({
+await client.subscribe({
   type: "subscribe",
   subscriptionId: 1,
   priceFeedIds: [1, 2],
@@ -48,7 +51,7 @@ client.subscribe({
   parsed: false,
   jsonBinaryEncoding: "base64",
 });
-client.subscribe({
+await client.subscribe({
   type: "subscribe",
   subscriptionId: 2,
   priceFeedIds: [1, 2, 3, 4, 5],
@@ -60,8 +63,8 @@ client.subscribe({
   jsonBinaryEncoding: "hex",
 });
 
-await new Promise((resolve) => setTimeout(resolve, 10000));
+await new Promise((resolve) => setTimeout(resolve, 10_000));
 
-client.unsubscribe(1);
-client.unsubscribe(2);
+await client.unsubscribe(1);
+await client.unsubscribe(2);
 client.shutdown();

lazer/sdk/js/src/client.ts

@@ -1,4 +1,5 @@
 import WebSocket from "isomorphic-ws";
+import { dummyLogger, type Logger } from "ts-log";
 
 import {
   BINARY_UPDATE_FORMAT_MAGIC,
@@ -9,8 +10,7 @@ import {
   type Response,
   SOLANA_FORMAT_MAGIC_BE,
 } from "./protocol.js";
-import { WebSocketPool } from "./socket/WebSocketPool.js";
-import { dummyLogger, type Logger } from "ts-log";
+import { WebSocketPool } from "./socket/web-socket-pool.js";
 
 export type BinaryResponse = {
   subscriptionId: number;
@@ -34,15 +34,15 @@ export class PythLazerClient {
 
   /**
    * Creates a new PythLazerClient instance.
-   * @param urls List of WebSocket URLs of the Pyth Lazer service
-   * @param token The access token for authentication
-   * @param numConnections The number of parallel WebSocket connections to establish (default: 3). A higher number gives a more reliable stream.
-   * @param logger Optional logger to get socket level logs. Compatible with most loggers such as the built-in console and `bunyan`.
+   * @param urls - List of WebSocket URLs of the Pyth Lazer service
+   * @param token - The access token for authentication
+   * @param numConnections - The number of parallel WebSocket connections to establish (default: 3). A higher number gives a more reliable stream.
+   * @param logger - Optional logger to get socket level logs. Compatible with most loggers such as the built-in console and `bunyan`.
    */
   constructor(
     urls: string[],
     token: string,
-    numConnections: number = 3,
+    numConnections = 3,
     logger: Logger = dummyLogger
   ) {
     this.wsp = new WebSocketPool(urls, token, numConnections, logger);
@@ -95,19 +95,19 @@ export class PythLazerClient {
     });
   }
 
-  subscribe(request: Request) {
+  async subscribe(request: Request): Promise<void> {
     if (request.type !== "subscribe") {
       throw new Error("Request must be a subscribe request");
     }
-    this.wsp.addSubscription(request);
+    await this.wsp.addSubscription(request);
   }
 
-  unsubscribe(subscriptionId: number) {
-    this.wsp.removeSubscription(subscriptionId);
+  async unsubscribe(subscriptionId: number): Promise<void> {
+    await this.wsp.removeSubscription(subscriptionId);
   }
 
-  send(request: Request) {
-    this.wsp.sendRequest(request);
+  async send(request: Request): Promise<void> {
+    await this.wsp.sendRequest(request);
   }
 
   shutdown(): void {

lazer/sdk/js/src/socket/ResillientWebSocket.ts renamed to lazer/sdk/js/src/socket/resilient-web-socket.ts

@@ -1,9 +1,10 @@
-import WebSocket, { type ClientOptions } from "isomorphic-ws";
 import type { ClientRequestArgs } from "node:http";
+
+import WebSocket, { type ClientOptions, type ErrorEvent } from "isomorphic-ws";
 import type { Logger } from "ts-log";
 
 // Reconnect with expo backoff if we don't get a message or ping for 10 seconds
-const HEARTBEAT_TIMEOUT_DURATION = 10000;
+const HEARTBEAT_TIMEOUT_DURATION = 10_000;
 
 /**
  * This class wraps websocket to provide a resilient web socket client.
@@ -24,7 +25,7 @@ export class ResilientWebSocket {
   private heartbeatTimeout: undefined | NodeJS.Timeout;
   private logger: undefined | Logger;
 
-  onError: (error: Error) => void;
+  onError: (error: ErrorEvent) => void;
   onMessage: (data: WebSocket.Data) => void;
   onReconnect: () => void;
   constructor(
@@ -37,16 +38,20 @@ export class ResilientWebSocket {
     this.logger = logger;
 
     this.wsFailedAttempts = 0;
-    this.onError = (error: Error) => {
-      this.logger?.error(error);
+    this.onError = (error: ErrorEvent) => {
+      this.logger?.error(error.error);
     };
     this.wsUserClosed = true;
-    this.onMessage = () => {};
-    this.onReconnect = () => {};
+    this.onMessage = (data: WebSocket.Data): void => {
+      void data;
+    };
+    this.onReconnect = (): void => {
+      // Empty function, can be set by the user.
+    };
   }
 
-  async send(data: any) {
-    this.logger?.info(`Sending ${data}`);
+  async send(data: string | Buffer) {
+    this.logger?.info(`Sending message`);
 
     await this.waitForMaybeReadyWebSocket();
 
@@ -55,11 +60,11 @@ export class ResilientWebSocket {
         "Couldn't connect to the websocket server. Error callback is called."
       );
     } else {
-      this.wsClient?.send(data);
+      this.wsClient.send(data);
     }
   }
 
-  async startWebSocket() {
+  startWebSocket(): void {
     if (this.wsClient !== undefined) {
       return;
     }
@@ -69,42 +74,26 @@ export class ResilientWebSocket {
     this.wsClient = new WebSocket(this.endpoint, this.wsOptions);
     this.wsUserClosed = false;
 
-    this.wsClient.onopen = () => {
+    this.wsClient.addEventListener("open", () => {
       this.wsFailedAttempts = 0;
       this.resetHeartbeat();
-    };
+    });
 
-    this.wsClient.onerror = (event) => {
-      this.onError(event.error);
-    };
+    this.wsClient.addEventListener("error", (event) => {
+      this.onError(event);
+    });
 
-    this.wsClient.onmessage = (event) => {
+    this.wsClient.addEventListener("message", (event) => {
       this.resetHeartbeat();
       this.onMessage(event.data);
-    };
+    });
 
-    this.wsClient.onclose = async () => {
-      if (this.heartbeatTimeout !== undefined) {
-        clearTimeout(this.heartbeatTimeout);
-      }
-
-      if (this.wsUserClosed === false) {
-        this.wsFailedAttempts += 1;
-        this.wsClient = undefined;
-        const waitTime = expoBackoff(this.wsFailedAttempts);
-
-        this.logger?.error(
-          `Connection closed unexpectedly or because of timeout. Reconnecting after ${waitTime}ms.`
-        );
-
-        await sleep(waitTime);
-        this.restartUnexpectedClosedWebsocket();
-      } else {
-        this.logger?.info("The connection has been closed successfully.");
-      }
-    };
+    this.wsClient.addEventListener("close", () => {
+      void this.handleClose();
+    });
 
-    if (this.wsClient.on !== undefined) {
+    // Handle ping events if supported (Node.js only)
+    if ("on" in this.wsClient) {
       // Ping handler is undefined in browser side
       this.wsClient.on("ping", () => {
         this.logger?.info("Ping received");
@@ -118,19 +107,19 @@ export class ResilientWebSocket {
    * from the server. If we don't receive any message within HEARTBEAT_TIMEOUT_DURATION,
    * we assume the connection is dead and reconnect.
    */
-  private resetHeartbeat() {
+  private resetHeartbeat(): void {
     if (this.heartbeatTimeout !== undefined) {
       clearTimeout(this.heartbeatTimeout);
     }
 
     this.heartbeatTimeout = setTimeout(() => {
-      this.logger?.warn(`Connection timed out. Reconnecting...`);
+      this.logger?.warn("Connection timed out. Reconnecting...");
       this.wsClient?.terminate();
-      this.restartUnexpectedClosedWebsocket();
+      void this.restartUnexpectedClosedWebsocket();
     }, HEARTBEAT_TIMEOUT_DURATION);
   }
 
-  private async waitForMaybeReadyWebSocket() {
+  private async waitForMaybeReadyWebSocket(): Promise<void> {
     let waitedTime = 0;
     while (
       this.wsClient !== undefined &&
@@ -146,12 +135,35 @@ export class ResilientWebSocket {
     }
   }
 
-  private async restartUnexpectedClosedWebsocket() {
-    if (this.wsUserClosed === true) {
+  private async handleClose(): Promise<void> {
+    if (this.heartbeatTimeout !== undefined) {
+      clearTimeout(this.heartbeatTimeout);
+    }
+
+    if (this.wsUserClosed) {
+      this.logger?.info("The connection has been closed successfully.");
+    } else {
+      this.wsFailedAttempts += 1;
+      this.wsClient = undefined;
+      const waitTime = expoBackoff(this.wsFailedAttempts);
+
+      this.logger?.error(
+        "Connection closed unexpectedly or because of timeout. Reconnecting after " +
+          String(waitTime) +
+          "ms."
+      );
+
+      await sleep(waitTime);
+      await this.restartUnexpectedClosedWebsocket();
+    }
+  }
+
+  private async restartUnexpectedClosedWebsocket(): Promise<void> {
+    if (this.wsUserClosed) {
       return;
     }
 
-    await this.startWebSocket();
+    this.startWebSocket();
     await this.waitForMaybeReadyWebSocket();
 
     if (this.wsClient === undefined) {
@@ -164,7 +176,7 @@ export class ResilientWebSocket {
     this.onReconnect();
   }
 
-  closeWebSocket() {
+  closeWebSocket(): void {
     if (this.wsClient !== undefined) {
       const client = this.wsClient;
       this.wsClient = undefined;
@@ -174,7 +186,7 @@ export class ResilientWebSocket {
   }
 }
 
-async function sleep(ms: number) {
+async function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }