@nktkas/hyperliquid 0.25.0-beta.2 → 0.25.0-beta.4

package/src/src/transports/websocket/_websocket_async_request.ts

@@ -1,28 +1,35 @@
+import { TransportError } from "../base.js";
+import { Promise_ } from "../_polyfills.js";
 import type { ReconnectingWebSocket } from "./_reconnecting_websocket.js";
-import type { HyperliquidEventMap, HyperliquidEventTarget } from "./_hyperliquid_event_target.js";
-import { WebSocketRequestError } from "./websocket_transport.js";
+import type { HyperliquidEventTarget } from "./_hyperliquid_event_target.js";
 
 interface PostRequest {
     method: "post";
     id: number;
     request: unknown;
 }
-
 interface SubscribeUnsubscribeRequest {
     method: "subscribe" | "unsubscribe";
     subscription: unknown;
 }
-
 interface PingRequest {
     method: "ping";
 }
 
+/** Error thrown when a WebSocket request fails. */
+export class WebSocketRequestError extends TransportError {
+    constructor(message?: string, options?: ErrorOptions) {
+        super(message, options);
+        this.name = "WebSocketRequestError";
+    }
+}
+
 /**
  * Manages WebSocket requests to the Hyperliquid API.
  * Handles request creation, sending, and mapping responses to their corresponding requests.
  */
 export class WebSocketAsyncRequest {
-    protected lastId: number = 0;
+    protected lastId = 0;
     protected queue: {
         id: number | string;
         // deno-lint-ignore no-explicit-any
@@ -30,7 +37,8 @@ export class WebSocketAsyncRequest {
         // deno-lint-ignore no-explicit-any
         reject: (reason?: any) => void;
     }[] = [];
-    lastRequestTime: number = 0;
+    /** Timestamp of the last request sent. */
+    lastRequestTime = 0;
 
     /**
      * Creates a new WebSocket async request handler.
@@ -40,35 +48,30 @@ export class WebSocketAsyncRequest {
     constructor(protected socket: ReconnectingWebSocket, hlEvents: HyperliquidEventTarget) {
         // Monitor responses and match the pending request
         hlEvents.addEventListener("subscriptionResponse", (event) => {
-            const detail = (event as HyperliquidEventMap["subscriptionResponse"]).detail;
-
-            // Use a stringified request as an id
-            const id = WebSocketAsyncRequest.requestToId(detail);
-            this.queue.findLast((item) => item.id === id)?.resolve(detail);
+            const id = WebSocketAsyncRequest.requestToId(event.detail);
+            this.queue.find((x) => x.id === id)?.resolve(event.detail);
         });
         hlEvents.addEventListener("post", (event) => {
-            const detail = (event as HyperliquidEventMap["post"]).detail;
-
-            const data = detail.response.type === "info" ? detail.response.payload.data : detail.response.payload;
-            this.queue.findLast((item) => item.id === detail.id)?.resolve(data);
+            const data = event.detail.response.type === "info"
+                ? event.detail.response.payload.data
+                : event.detail.response.payload;
+            this.queue.find((x) => x.id === event.detail.id)?.resolve(data);
         });
         hlEvents.addEventListener("pong", () => {
-            this.queue.findLast((item) => item.id === "ping")?.resolve();
+            this.queue.find((x) => x.id === "ping")?.resolve();
         });
         hlEvents.addEventListener("error", (event) => {
-            const detail = (event as HyperliquidEventMap["error"]).detail;
-
             try {
                 // Error event doesn't have an id, use original request to match
-                const request = detail.match(/{.*}/)?.[0];
+                const request = event.detail.match(/{.*}/)?.[0];
                 if (!request) return;
 
-                const parsedRequest = JSON.parse(request) as Record<string, unknown>;
+                const parsedRequest = JSON.parse(request);
 
                 // For `post` requests
                 if ("id" in parsedRequest && typeof parsedRequest.id === "number") {
-                    this.queue.findLast((item) => item.id === parsedRequest.id)
-                        ?.reject(new WebSocketRequestError(`Server error: ${detail}`, { cause: detail }));
+                    this.queue.find((x) => x.id === parsedRequest.id)
+                        ?.reject(new WebSocketRequestError(event.detail));
                     return;
                 }
 
@@ -78,48 +81,54 @@ export class WebSocketAsyncRequest {
                     typeof parsedRequest.subscription === "object" && parsedRequest.subscription !== null
                 ) {
                     const id = WebSocketAsyncRequest.requestToId(parsedRequest);
-                    this.queue.findLast((item) => item.id === id)
-                        ?.reject(new WebSocketRequestError(`Server error: ${detail}`, { cause: detail }));
+                    this.queue.find((x) => x.id === id)
+                        ?.reject(new WebSocketRequestError(event.detail));
                     return;
                 }
 
                 // For `Already subscribed` and `Invalid subscription` requests
-                if (detail.startsWith("Already subscribed") || detail.startsWith("Invalid subscription")) {
+                if (
+                    event.detail.startsWith("Already subscribed") ||
+                    event.detail.startsWith("Invalid subscription")
+                ) {
                     const id = WebSocketAsyncRequest.requestToId({
                         method: "subscribe",
                         subscription: parsedRequest,
                     });
-                    this.queue.findLast((item) => item.id === id)
-                        ?.reject(new WebSocketRequestError(`Server error: ${detail}`, { cause: detail }));
+                    this.queue.find((x) => x.id === id)
+                        ?.reject(new WebSocketRequestError(event.detail));
                     return;
                 }
+
                 // For `Already unsubscribed` requests
-                if (detail.startsWith("Already unsubscribed")) {
+                if (event.detail.startsWith("Already unsubscribed")) {
                     const id = WebSocketAsyncRequest.requestToId({
                         method: "unsubscribe",
                         subscription: parsedRequest,
                     });
-                    this.queue.findLast((item) => item.id === id)
-                        ?.reject(new WebSocketRequestError(`Server error: ${detail}`, { cause: detail }));
+                    this.queue.find((x) => x.id === id)
+                        ?.reject(new WebSocketRequestError(event.detail));
                     return;
                 }
 
                 // For unknown requests
                 const id = WebSocketAsyncRequest.requestToId(parsedRequest);
-                this.queue.findLast((item) => item.id === id)
-                    ?.reject(new WebSocketRequestError(`Server error: ${detail}`, { cause: detail }));
+                this.queue.find((x) => x.id === id)
+                    ?.reject(new WebSocketRequestError(event.detail));
             } catch {
                 // Ignore JSON parsing errors
             }
         });
 
         // Throws all pending requests if the connection is dropped
-        socket.addEventListener("close", () => {
+        const handleClose = () => {
             this.queue.forEach(({ reject }) => {
                 reject(new WebSocketRequestError("WebSocket connection closed."));
             });
             this.queue = [];
-        });
+        };
+        socket.addEventListener("close", handleClose);
+        socket.addEventListener("error", handleClose);
     }
 
     /**
@@ -130,17 +139,17 @@ export class WebSocketAsyncRequest {
     async request<T>(method: "post" | "subscribe" | "unsubscribe", payload: unknown, signal?: AbortSignal): Promise<T>;
     async request<T>(
         method: "post" | "subscribe" | "unsubscribe" | "ping",
-        payload_or_signal?: unknown | AbortSignal,
+        payloadOrSignal?: unknown | AbortSignal,
         maybeSignal?: AbortSignal,
     ): Promise<T> {
-        const payload = payload_or_signal instanceof AbortSignal ? undefined : payload_or_signal;
-        const signal = payload_or_signal instanceof AbortSignal ? payload_or_signal : maybeSignal;
+        const payload = payloadOrSignal instanceof AbortSignal ? undefined : payloadOrSignal;
+        const signal = payloadOrSignal instanceof AbortSignal ? payloadOrSignal : maybeSignal;
 
         // Reject the request if the signal is aborted
         if (signal?.aborted) return Promise.reject(signal.reason);
         // or if the WebSocket connection is permanently closed
-        if (this.socket.reconnectAbortController.signal.aborted) {
-            return Promise.reject(this.socket.reconnectAbortController.signal.reason);
+        if (this.socket.terminateSignal.aborted) {
+            return Promise.reject(this.socket.terminateSignal.reason);
         }
 
         // Create a request
@@ -162,14 +171,14 @@ export class WebSocketAsyncRequest {
         this.lastRequestTime = Date.now();
 
         // Wait for a response
-        const { promise, resolve, reject } = Promise.withResolvers<T>();
+        const { promise, resolve, reject } = Promise_.withResolvers<T>();
         this.queue.push({ id, resolve, reject });
 
         const onAbort = () => reject(signal?.reason);
         signal?.addEventListener("abort", onAbort, { once: true });
 
         return await promise.finally(() => {
-            const index = this.queue.findLastIndex((item) => item.id === id);
+            const index = this.queue.findIndex((item) => item.id === id);
             if (index !== -1) this.queue.splice(index, 1);
 
             signal?.removeEventListener("abort", onAbort);
@@ -179,51 +188,40 @@ export class WebSocketAsyncRequest {
     /** Normalizes an object and then converts it to a string. */
     static requestToId(value: unknown): string {
         const lowerHex = deepLowerHex(value);
-        const sorted = deepSortKeys(lowerHex);
-        return JSON.stringify(sorted); // Also removes undefined
+        const sortedKeys = deepSortKeys(lowerHex);
+        return JSON.stringify(sortedKeys); // also removes undefined
     }
 }
 
-/** Deeply converts hexadecimal strings in an object/array to lowercase. */
+/** Deeply converts hexadecimal strings to lowercase in an object/array. */
 function deepLowerHex(obj: unknown): unknown {
     if (typeof obj === "string") {
-        return /^(0X[0-9a-fA-F]*|0x[0-9a-fA-F]*[A-F][0-9a-fA-F]*)$/.test(obj) ? obj.toLowerCase() : obj;
+        return /^0[xX][0-9a-fA-F]+$/.test(obj) ? obj.toLowerCase() : obj;
     }
-
     if (Array.isArray(obj)) {
         return obj.map((value) => deepLowerHex(value));
     }
-
     if (typeof obj === "object" && obj !== null) {
         const result: Record<string, unknown> = {};
-        const entries = Object.entries(obj);
-
-        for (const [key, value] of entries) {
+        for (const [key, value] of Object.entries(obj)) {
             result[key] = deepLowerHex(value);
         }
-
         return result;
     }
-
     return obj;
 }
 
-/** Deeply sort the keys of an object. */
+/** Deeply sort keys of an object alphabetically. */
 function deepSortKeys<T>(obj: T): T {
     if (typeof obj !== "object" || obj === null) {
         return obj;
     }
-
     if (Array.isArray(obj)) {
         return obj.map(deepSortKeys) as T;
     }
-
     const result: Record<string, unknown> = {};
-    const keys = Object.keys(obj).sort();
-
-    for (const key of keys) {
+    for (const key of Object.keys(obj).sort()) {
         result[key] = deepSortKeys((obj as Record<string, unknown>)[key]);
     }
-
     return result as T;
 }