@nktkas/hyperliquid 0.13.1 → 0.14.0

package/esm/src/transports/websocket/websocket_transport.js

@@ -1,9 +1,8 @@
-import { ReconnectingWebSocket } from "./reconnecting_websocket.js";
-import { HyperliquidEventTarget } from "./hyperliquid_event_target.js";
-import { WebSocketRequestDispatcher } from "./websocket_request_dispatcher.js";
-/**
- * WebSocket implementation of the REST and Subscription transport interfaces.
- */
+import { ReconnectingWebSocket } from "./_reconnecting_websocket.js";
+import { HyperliquidEventTarget } from "./_hyperliquid_event_target.js";
+import { WebSocketRequestDispatcher, WebSocketRequestError } from "./_websocket_request_dispatcher.js";
+export { WebSocketRequestError };
+/** WebSocket implementation of the REST and Subscription transport interfaces. */
 export class WebSocketTransport {
     /**
      * Creates a new WebSocket transport instance.
@@ -15,7 +14,7 @@ export class WebSocketTransport {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: null
         });
         /** The WebSocket request dispatcher instance. */
         Object.defineProperty(this, "_wsRequester", {
@@ -33,8 +32,9 @@ export class WebSocketTransport {
         });
         /**
          * Map of active subscriptions.
-         * - Key: Unique subscription identifier (stringified payload)
-         * - Value: Subscription info containing payload and listener mappings
+         * - Key: Unique subscription identifier based on payload
+         * - Value: Subscription info containing the subscription request promise
+         *   and a map of listeners to their metadata (channel + unsubscribe function).
          */
         Object.defineProperty(this, "_subscriptions", {
             enumerable: true,
@@ -76,7 +76,7 @@ export class WebSocketTransport {
         // Initialize listeners
         this.socket.addEventListener("open", () => {
             // Start keep-alive timer
-            if (this.keepAlive.interval && !this._keepAliveTimer) {
+            if (this.keepAlive.interval && this._keepAliveTimer === null) {
                 this._keepAliveTimer = setInterval(() => {
                     this.socket.send(JSON.stringify({ method: "ping" }));
                 }, this.keepAlive.interval);
@@ -84,17 +84,16 @@ export class WebSocketTransport {
         });
         this.socket.addEventListener("close", () => {
             // Clear keep-alive timer
-            if (this._keepAliveTimer) {
+            if (this._keepAliveTimer !== null) {
                 clearInterval(this._keepAliveTimer);
-                this._keepAliveTimer = undefined;
+                this._keepAliveTimer = null;
             }
             // Clear all subscriptions
-            for (const [_, { channel, listeners }] of this._subscriptions.entries()) {
-                for (const [listener] of listeners) {
-                    this._hlEvents.removeEventListener(channel, listener);
+            for (const subscriptionInfo of this._subscriptions.values()) {
+                for (const [_, unsubscribe] of subscriptionInfo.listeners) {
+                    unsubscribe();
                 }
             }
-            this._subscriptions.clear();
         });
     }
     /**
@@ -109,10 +108,11 @@ export class WebSocketTransport {
     request(type, payload, signal) {
         // Reject explorer requests because they are not supported by the Hyperliquid WebSocket API
         if (type === "explorer") {
-            throw new Error("Explorer requests are not supported in the Hyperliquid WebSocket API.");
+            return Promise.reject(new WebSocketRequestError("Explorer requests are not supported in the Hyperliquid WebSocket API."));
         }
         // Send the request and wait for a response
-        return this._wsRequester.request("post", { type, payload }, this.combineSignals(signal));
+        const combinedSignal = this._combineTimeoutWithSignal(this.timeout, signal);
+        return this._wsRequester.request("post", { type, payload }, combinedSignal);
     }
     /**
      * Subscribes to a Hyperliquid event channel.
@@ -124,44 +124,52 @@ export class WebSocketTransport {
      */
     async subscribe(channel, payload, listener, signal) {
         // Create a unique identifier for the subscription
-        const id = `${channel}::${WebSocketRequestDispatcher.requestToId(payload)}`;
+        const id = WebSocketRequestDispatcher.requestToId(payload);
         // Initialize new subscription, if it doesn't exist
-        let subscriptionInfo = this._subscriptions.get(id);
-        if (!subscriptionInfo) {
+        let subscription = this._subscriptions.get(id);
+        if (!subscription) {
             // Send subscription request
-            const requestPromise = this._wsRequester.request("subscribe", payload, this.combineSignals(signal))
-                .catch((error) => {
-                this._subscriptions.delete(id);
-                throw error;
-            });
+            const combinedSignal = this._combineTimeoutWithSignal(this.timeout, signal);
+            const requestPromise = this._wsRequester.request("subscribe", payload, combinedSignal);
             // Cache subscription info
-            subscriptionInfo = { channel, listeners: new Map(), requestPromise };
-            this._subscriptions.set(id, subscriptionInfo);
+            subscription = { listeners: new Map(), requestPromise };
+            this._subscriptions.set(id, subscription);
         }
-        // Check if we already have an unsubscribe function for this listener
-        let unsubscribe = subscriptionInfo.listeners.get(listener);
+        // Initialize new listener, if it doesn't exist
+        let unsubscribe = subscription.listeners.get(listener);
         if (!unsubscribe) {
-            // Create new unsubscribe function if none exists
+            // Create new unsubscribe function
             unsubscribe = async (signal) => {
                 // Remove listener and cleanup
                 this._hlEvents.removeEventListener(channel, listener);
-                const isDeleted = subscriptionInfo.listeners.delete(listener);
+                const subscription = this._subscriptions.get(id);
+                subscription?.listeners.delete(listener);
                 // If no listeners remain, remove subscription entirely
-                // `isDeleted` means that the map had a listener before and became 0 after that
-                if (subscriptionInfo.listeners.size === 0 && isDeleted) {
+                if (subscription?.listeners.size === 0) {
+                    // Cleanup subscription
                     this._subscriptions.delete(id);
-                    await this._wsRequester.request("unsubscribe", payload, this.combineSignals(signal));
+                    // If the socket is open, send unsubscription request
+                    if (this.socket.readyState === WebSocket.OPEN) {
+                        const combinedSignal = this._combineTimeoutWithSignal(this.timeout, signal);
+                        await this._wsRequester.request("unsubscribe", payload, combinedSignal);
+                    }
                 }
             };
-            // Add event listener & Cache unsubscribe function
+            // Add listener and cache unsubscribe function
             this._hlEvents.addEventListener(channel, listener);
-            subscriptionInfo.listeners.set(listener, unsubscribe);
+            subscription.listeners.set(listener, unsubscribe);
         }
         // Wait for the initial subscription request to complete
-        await subscriptionInfo.requestPromise.catch((error) => {
-            // Cleanup the subscription and rethrow the error
+        await subscription.requestPromise.catch((error) => {
+            // Remove listener and cleanup
             this._hlEvents.removeEventListener(channel, listener);
-            subscriptionInfo.listeners.delete(listener);
+            const subscription = this._subscriptions.get(id);
+            subscription?.listeners.delete(listener);
+            // If no listeners remain, remove subscription entirely
+            if (subscription?.listeners.size === 0) {
+                this._subscriptions.delete(id);
+            }
+            // Rethrow the error
             throw error;
         });
         // Return subscription control object
@@ -217,17 +225,12 @@ export class WebSocketTransport {
             this.socket.close();
         });
     }
-    /**
-     * Combines timeout and user-provided signal.
-     * @param signal - A user-provided signal.
-     * @returns An AbortSignal that triggers when either the timeout or user-provided signal aborts.
-     */
-    combineSignals(signal) {
-        const signals = [];
-        if (this.timeout)
-            signals.push(AbortSignal.timeout(this.timeout));
-        if (signal)
-            signals.push(signal);
-        return signals.length > 1 ? AbortSignal.any(signals) : signals[0];
+    /** Combines a timeout with an optional abort signal. */
+    _combineTimeoutWithSignal(timeout, signal) {
+        if (typeof timeout !== "number")
+            return signal;
+        if (!(signal instanceof AbortSignal))
+            return AbortSignal.timeout(timeout);
+        return AbortSignal.any([AbortSignal.timeout(timeout), signal]);
     }
 }