@nktkas/hyperliquid 0.19.2 → 0.21.0

package/esm/src/clients/{event.js → subscription.js}

@@ -1,8 +1,9 @@
 /**
- * Event client for subscribing to various Hyperliquid events.
+ * Subscription client for subscribing to various Hyperliquid events.
  * @typeParam T The type of transport used to connect to the Hyperliquid Websocket API.
  */
-export class EventClient {
+export class SubscriptionClient {
+    transport;
     /**
      * Initialises a new instance.
      * @param args - The arguments for initialisation.
@@ -12,24 +13,16 @@ export class EventClient {
      * import * as hl from "@nktkas/hyperliquid";
      *
      * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
+     * const subsClient = new hl.SubscriptionClient({ transport });
      * ```
      */
     constructor(args) {
-        /** The transport used to connect to the Hyperliquid API. */
-        Object.defineProperty(this, "transport", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         this.transport = args.transport;
     }
     /**
      * Subscribe to context updates for a specific perpetual asset.
      * @param args - The parameters for the subscription.
      * @param listener - The callback function to be called when the event is received.
-     * @param signal - An optional abort signal for canceling the subscription request.
      * @returns A promise that resolves with a {@link Subscription} object to manage the subscription lifecycle.
      *
      * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
@@ -38,30 +31,29 @@ export class EventClient {
      * import * as hl from "@nktkas/hyperliquid";
      *
      * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
+     * const subsClient = new hl.SubscriptionClient({ transport });
      *
      * const sub = await client.activeAssetCtx({ coin: "BTC" }, (data) => {
      *   console.log(data);
      * });
      * ```
      */
-    activeAssetCtx(args, listener, signal) {
+    activeAssetCtx(args, listener) {
         const channel = args.coin.startsWith("@") ? "activeSpotAssetCtx" : "activeAssetCtx";
         const payload = {
             type: "activeAssetCtx",
             coin: args.coin,
         };
-        return this.transport.subscribe(channel, payload, (event) => {
-            if (event.detail.coin === args.coin) {
-                listener(event.detail);
+        return this.transport.subscribe(channel, payload, (e) => {
+            if (e.detail.coin === args.coin) {
+                listener(e.detail);
             }
-        }, signal);
+        });
     }
     /**
      * Subscribe to trading data updates for a specific asset and user.
      * @param args - The parameters for the subscription.
      * @param listener - The callback function to be called when the event is received.
-     * @param signal - An optional abort signal for canceling the subscription request.
      * @returns A promise that resolves with a {@link Subscription} object to manage the subscription lifecycle.
      *
      * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
@@ -70,46 +62,40 @@ export class EventClient {
      * import * as hl from "@nktkas/hyperliquid";
      *
      * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
+     * const subsClient = new hl.SubscriptionClient({ transport });
      *
      * const sub = await client.activeAssetData({ coin: "BTC", user: "0x..." }, (data) => {
      *   console.log(data);
      * });
      * ```
      */
-    activeAssetData(args, listener, signal) {
+    activeAssetData(args, listener) {
         const payload = {
             type: "activeAssetData",
             coin: args.coin,
             user: args.user,
         };
-        return this.transport.subscribe(payload.type, payload, (event) => {
-            if (event.detail.coin === args.coin && event.detail.user === args.user.toLowerCase()) {
-                listener(event.detail);
+        return this.transport.subscribe(payload.type, payload, (e) => {
+            if (e.detail.coin === args.coin && e.detail.user === args.user.toLowerCase()) {
+                listener(e.detail);
             }
-        }, signal);
+        });
     }
-    allMids(args_or_listener, listener_or_signal, maybeSignal) {
+    allMids(args_or_listener, maybeListener) {
         const args = typeof args_or_listener === "function" ? {} : args_or_listener;
-        const listener = typeof args_or_listener === "function"
-            ? args_or_listener
-            : listener_or_signal;
-        const signal = typeof args_or_listener === "function"
-            ? listener_or_signal
-            : maybeSignal;
+        const listener = typeof args_or_listener === "function" ? args_or_listener : maybeListener;
         const payload = {
             type: "allMids",
             dex: args.dex,
         };
-        return this.transport.subscribe(payload.type, payload, (event) => {
-            listener(event.detail);
-        }, signal);
+        return this.transport.subscribe(payload.type, payload, (e) => {
+            listener(e.detail);
+        });
     }
     /**
      * Subscribe to best bid and offer updates for a specific asset.
      * @param args - The parameters for the subscription.
      * @param listener - The callback function to be called when the event is received.
-     * @param signal - An optional abort signal for canceling the subscription request.
      * @returns A promise that resolves with a {@link Subscription} object to manage the subscription lifecycle.
      *
      * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
@@ -118,29 +104,28 @@ export class EventClient {
      * import * as hl from "@nktkas/hyperliquid";
      *
      * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
+     * const subsClient = new hl.SubscriptionClient({ transport });
      *
      * const sub = await client.bbo({ coin: "BTC" }, (data) => {
      *   console.log(data);
      * });
      * ```
      */
-    bbo(args, listener, signal) {
+    bbo(args, listener) {
         const payload = {
             type: "bbo",
             coin: args.coin,
         };
-        return this.transport.subscribe(payload.type, payload, (event) => {
-            if (event.detail.coin === args.coin) {
-                listener(event.detail);
+        return this.transport.subscribe(payload.type, payload, (e) => {
+            if (e.detail.coin === args.coin) {
+                listener(e.detail);
             }
-        }, signal);
+        });
     }
     /**
      * Subscribe to candlestick data updates for a specific asset.
      * @param args - The parameters for the subscription.
      * @param listener - The callback function to be called when the event is received.
-     * @param signal - An optional abort signal for canceling the subscription request.
      * @returns A promise that resolves with a {@link Subscription} object to manage the subscription lifecycle.
      *
      * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
@@ -149,29 +134,28 @@ export class EventClient {
      * import * as hl from "@nktkas/hyperliquid";
      *
      * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
+     * const subsClient = new hl.SubscriptionClient({ transport });
      *
      * const sub = await client.candle({ coin: "BTC", interval: "1h" }, (data) => {
      *   console.log(data);
      * });
      * ```
      */
-    candle(args, listener, signal) {
+    candle(args, listener) {
         const payload = {
             type: "candle",
             coin: args.coin,
             interval: args.interval,
         };
-        return this.transport.subscribe(payload.type, payload, (event) => {
-            if (event.detail.s === args.coin && event.detail.i === args.interval) {
-                listener(event.detail);
+        return this.transport.subscribe(payload.type, payload, (e) => {
+            if (e.detail.s === args.coin && e.detail.i === args.interval) {
+                listener(e.detail);
             }
-        }, signal);
+        });
     }
     /**
      * Subscribe to explorer block updates.
      * @param listener - The callback function to be called when the event is received.
-     * @param signal - An optional abort signal for canceling the subscription request.
      * @returns A promise that resolves with a {@link Subscription} object to manage the subscription lifecycle.
      * @note Make sure the endpoint in the {@link transport} supports this method.
      *
@@ -181,26 +165,24 @@ export class EventClient {
      * import * as hl from "@nktkas/hyperliquid";
      *
      * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
+     * const subsClient = new hl.SubscriptionClient({ transport });
      *
      * const sub = await client.explorerBlock((data) => {
      *   console.log(data);
      * });
      * ```
      */
-    explorerBlock(listener, signal) {
+    explorerBlock(listener) {
         const payload = {
             type: "explorerBlock",
         };
-        return this.transport.subscribe("_explorerBlock", // Internal channel as it does not have its own channel
-        payload, (event) => {
-            listener(event.detail);
-        }, signal);
+        return this.transport.subscribe("_explorerBlock", payload, (e) => {
+            listener(e.detail);
+        });
     }
     /**
      * Subscribe to explorer transaction updates.
      * @param listener - The callback function to be called when the event is received.
-     * @param signal - An optional abort signal for canceling the subscription request.
      * @returns A promise that resolves with a {@link Subscription} object to manage the subscription lifecycle.
      * @note Make sure the endpoint in the {@link transport} supports this method.
      *
@@ -210,27 +192,25 @@ export class EventClient {
      * import * as hl from "@nktkas/hyperliquid";
      *
      * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
+     * const subsClient = new hl.SubscriptionClient({ transport });
      *
      * const sub = await client.explorerTxs((data) => {
      *   console.log(data);
      * });
      * ```
      */
-    explorerTxs(listener, signal) {
+    explorerTxs(listener) {
         const payload = {
             type: "explorerTxs",
         };
-        return this.transport.subscribe("_explorerTxs", // Internal channel as it does not have its own channel
-        payload, (event) => {
-            listener(event.detail);
-        }, signal);
+        return this.transport.subscribe("_explorerTxs", payload, (e) => {
+            listener(e.detail);
+        });
     }
     /**
      * Subscribe to L2 order book updates for a specific asset.
      * @param args - The parameters for the subscription.
      * @param listener - The callback function to be called when the event is received.
-     * @param signal - An optional abort signal for canceling the subscription request.
      * @returns A promise that resolves with a {@link Subscription} object to manage the subscription lifecycle.
      *
      * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
@@ -239,31 +219,30 @@ export class EventClient {
      * import * as hl from "@nktkas/hyperliquid";
      *
      * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
+     * const subsClient = new hl.SubscriptionClient({ transport });
      *
      * const sub = await client.l2Book({ coin: "BTC" }, (data) => {
      *   console.log(data);
      * });
      * ```
      */
-    l2Book(args, listener, signal) {
+    l2Book(args, listener) {
         const payload = {
             type: "l2Book",
             coin: args.coin,
             nSigFigs: args.nSigFigs ?? null,
             mantissa: args.mantissa ?? null,
         };
-        return this.transport.subscribe(payload.type, payload, (event) => {
-            if (event.detail.coin === args.coin) {
-                listener(event.detail);
+        return this.transport.subscribe(payload.type, payload, (e) => {
+            if (e.detail.coin === args.coin) {
+                listener(e.detail);
             }
-        }, signal);
+        });
     }
     /**
      * Subscribe to notification updates for a specific user.
      * @param args - The parameters for the subscription.
      * @param listener - The callback function to be called when the event is received.
-     * @param signal - An optional abort signal for canceling the subscription request.
      * @returns A promise that resolves with a {@link Subscription} object to manage the subscription lifecycle.
      *
      * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
@@ -272,27 +251,26 @@ export class EventClient {
      * import * as hl from "@nktkas/hyperliquid";
      *
      * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
+     * const subsClient = new hl.SubscriptionClient({ transport });
      *
      * const sub = await client.notification({ user: "0x..." }, (data) => {
      *   console.log(data);
      * });
      * ```
      */
-    notification(args, listener, signal) {
+    notification(args, listener) {
         const payload = {
             type: "notification",
             user: args.user,
         };
-        return this.transport.subscribe(payload.type, payload, (event) => {
-            listener(event.detail);
-        }, signal);
+        return this.transport.subscribe(payload.type, payload, (e) => {
+            listener(e.detail);
+        });
     }
     /**
      * Subscribe to order status updates for a specific user.
      * @param args - The parameters for the subscription.
      * @param listener - The callback function to be called when the event is received.
-     * @param signal - An optional abort signal for canceling the subscription request.
      * @returns A promise that resolves with a {@link Subscription} object to manage the subscription lifecycle.
      *
      * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
@@ -301,27 +279,26 @@ export class EventClient {
      * import * as hl from "@nktkas/hyperliquid";
      *
      * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
+     * const subsClient = new hl.SubscriptionClient({ transport });
      *
      * const sub = await client.orderUpdates({ user: "0x..." }, (data) => {
      *   console.log(data);
      * });
      * ```
      */
-    orderUpdates(args, listener, signal) {
+    orderUpdates(args, listener) {
         const payload = {
             type: "orderUpdates",
             user: args.user,
         };
-        return this.transport.subscribe(payload.type, payload, (event) => {
-            listener(event.detail);
-        }, signal);
+        return this.transport.subscribe(payload.type, payload, (e) => {
+            listener(e.detail);
+        });
     }
     /**
      * Subscribe to real-time trade updates for a specific asset.
      * @param args - The parameters for the subscription.
      * @param listener - The callback function to be called when the event is received.
-     * @param signal - An optional abort signal for canceling the subscription request.
      * @returns A promise that resolves with a {@link Subscription} object to manage the subscription lifecycle.
      *
      * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
@@ -330,29 +307,28 @@ export class EventClient {
      * import * as hl from "@nktkas/hyperliquid";
      *
      * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
+     * const subsClient = new hl.SubscriptionClient({ transport });
      *
      * const sub = await client.trades({ coin: "BTC" }, (data) => {
      *   console.log(data);
      * });
      * ```
      */
-    trades(args, listener, signal) {
+    trades(args, listener) {
         const payload = {
             type: "trades",
             coin: args.coin,
         };
-        return this.transport.subscribe(payload.type, payload, (event) => {
-            if (event.detail[0]?.coin === args.coin) {
-                listener(event.detail);
+        return this.transport.subscribe(payload.type, payload, (e) => {
+            if (e.detail[0]?.coin === args.coin) {
+                listener(e.detail);
             }
-        }, signal);
+        });
     }
     /**
      * Subscribe to non-order events for a specific user.
      * @param args - The parameters for the subscription.
      * @param listener - The callback function to be called when the event is received.
-     * @param signal - An optional abort signal for canceling the subscription request.
      * @returns A promise that resolves with a {@link Subscription} object to manage the subscription lifecycle.
      *
      * @note Different subscriptions cannot be distinguished from each other.
@@ -363,27 +339,26 @@ export class EventClient {
      * import * as hl from "@nktkas/hyperliquid";
      *
      * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
+     * const subsClient = new hl.SubscriptionClient({ transport });
      *
      * const sub = await client.userEvents({ user: "0x..." }, (data) => {
      *   console.log(data);
      * });
      * ```
      */
-    userEvents(args, listener, signal) {
+    userEvents(args, listener) {
         const payload = {
             type: "userEvents",
             user: args.user,
         };
-        return this.transport.subscribe("user", payload, (event) => {
-            listener(event.detail);
-        }, signal);
+        return this.transport.subscribe("user", payload, (e) => {
+            listener(e.detail);
+        });
     }
     /**
      * Subscribe to trade fill updates for a specific user.
      * @param args - The parameters for the subscription.
      * @param listener - The callback function to be called when the event is received.
-     * @param signal - An optional abort signal for canceling the subscription request.
      * @returns A promise that resolves with a {@link Subscription} object to manage the subscription lifecycle.
      *
      * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
@@ -392,30 +367,29 @@ export class EventClient {
      * import * as hl from "@nktkas/hyperliquid";
      *
      * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
+     * const subsClient = new hl.SubscriptionClient({ transport });
      *
      * const sub = await client.userFills({ user: "0x..." }, (data) => {
      *   console.log(data);
      * });
      * ```
      */
-    userFills(args, listener, signal) {
+    userFills(args, listener) {
         const payload = {
             type: "userFills",
             user: args.user,
             aggregateByTime: args.aggregateByTime ?? false,
         };
-        return this.transport.subscribe(payload.type, payload, (event) => {
-            if (event.detail.user === args.user.toLowerCase()) {
-                listener(event.detail);
+        return this.transport.subscribe(payload.type, payload, (e) => {
+            if (e.detail.user === args.user.toLowerCase()) {
+                listener(e.detail);
             }
-        }, signal);
+        });
     }
     /**
      * Subscribe to funding payment updates for a specific user.
      * @param args - The parameters for the subscription.
      * @param listener - The callback function to be called when the event is received.
-     * @param signal - An optional abort signal for canceling the subscription request.
      * @returns A promise that resolves with a {@link Subscription} object to manage the subscription lifecycle.
      *
      * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
@@ -424,29 +398,28 @@ export class EventClient {
      * import * as hl from "@nktkas/hyperliquid";
      *
      * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
+     * const subsClient = new hl.SubscriptionClient({ transport });
      *
      * const sub = await client.userFundings({ user: "0x..." }, (data) => {
      *   console.log(data);
      * });
      * ```
      */
-    userFundings(args, listener, signal) {
+    userFundings(args, listener) {
         const payload = {
             type: "userFundings",
             user: args.user,
         };
-        return this.transport.subscribe(payload.type, payload, (event) => {
-            if (event.detail.user === args.user.toLowerCase()) {
-                listener(event.detail);
+        return this.transport.subscribe(payload.type, payload, (e) => {
+            if (e.detail.user === args.user.toLowerCase()) {
+                listener(e.detail);
             }
-        }, signal);
+        });
     }
     /**
      * Subscribe to non-funding ledger updates for a specific user.
      * @param args - The parameters for the subscription.
      * @param listener - The callback function to be called when the event is received.
-     * @param signal - An optional abort signal for canceling the subscription request.
      * @returns A promise that resolves with a {@link Subscription} object to manage the subscription lifecycle.
      *
      * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
@@ -455,29 +428,28 @@ export class EventClient {
      * import * as hl from "@nktkas/hyperliquid";
      *
      * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
+     * const subsClient = new hl.SubscriptionClient({ transport });
      *
      * const sub = await client.userNonFundingLedgerUpdates({ user: "0x..." }, (data) => {
      *   console.log(data);
      * });
      * ```
      */
-    userNonFundingLedgerUpdates(args, listener, signal) {
+    userNonFundingLedgerUpdates(args, listener) {
         const payload = {
             type: "userNonFundingLedgerUpdates",
             user: args.user,
         };
-        return this.transport.subscribe(payload.type, payload, (event) => {
-            if (event.detail.user === args.user.toLowerCase()) {
-                listener(event.detail);
+        return this.transport.subscribe(payload.type, payload, (e) => {
+            if (e.detail.user === args.user.toLowerCase()) {
+                listener(e.detail);
             }
-        }, signal);
+        });
     }
     /**
      * Subscribe to TWAP order history updates for a specific user.
      * @param args - The parameters for the subscription.
      * @param listener - The callback function to be called when the event is received.
-     * @param signal - An optional abort signal for canceling the subscription request.
      * @returns A promise that resolves with a {@link Subscription} object to manage the subscription lifecycle.
      *
      * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
@@ -486,29 +458,28 @@ export class EventClient {
      * import * as hl from "@nktkas/hyperliquid";
      *
      * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
+     * const subsClient = new hl.SubscriptionClient({ transport });
      *
      * const sub = await client.userTwapHistory({ user: "0x..." }, (data) => {
      *   console.log(data);
      * });
      * ```
      */
-    userTwapHistory(args, listener, signal) {
+    userTwapHistory(args, listener) {
         const payload = {
             type: "userTwapHistory",
             user: args.user,
         };
-        return this.transport.subscribe(payload.type, payload, (event) => {
-            if (event.detail.user === args.user.toLowerCase()) {
-                listener(event.detail);
+        return this.transport.subscribe(payload.type, payload, (e) => {
+            if (e.detail.user === args.user.toLowerCase()) {
+                listener(e.detail);
             }
-        }, signal);
+        });
     }
     /**
      * Subscribe to TWAP execution updates for a specific user.
      * @param args - The parameters for the subscription.
      * @param listener - The callback function to be called when the event is received.
-     * @param signal - An optional abort signal for canceling the subscription request.
      * @returns A promise that resolves with a {@link Subscription} object to manage the subscription lifecycle.
      *
      * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
@@ -517,29 +488,28 @@ export class EventClient {
      * import * as hl from "@nktkas/hyperliquid";
      *
      * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
+     * const subsClient = new hl.SubscriptionClient({ transport });
      *
      * const sub = await client.userTwapSliceFills({ user: "0x..." }, (data) => {
      *   console.log(data);
      * });
      * ```
      */
-    userTwapSliceFills(args, listener, signal) {
+    userTwapSliceFills(args, listener) {
         const payload = {
             type: "userTwapSliceFills",
             user: args.user,
         };
-        return this.transport.subscribe(payload.type, payload, (event) => {
-            if (event.detail.user === args.user.toLowerCase()) {
-                listener(event.detail);
+        return this.transport.subscribe(payload.type, payload, (e) => {
+            if (e.detail.user === args.user.toLowerCase()) {
+                listener(e.detail);
             }
-        }, signal);
+        });
     }
     /**
      * Subscribe to comprehensive user and market data updates.
      * @param args - The parameters for the subscription.
      * @param listener - The callback function to be called when the event is received.
-     * @param signal - An optional abort signal for canceling the subscription request.
      * @returns A promise that resolves with a {@link Subscription} object to manage the subscription lifecycle.
      *
      * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
@@ -548,23 +518,23 @@ export class EventClient {
      * import * as hl from "@nktkas/hyperliquid";
      *
      * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
+     * const subsClient = new hl.SubscriptionClient({ transport });
      *
      * const sub = await client.webData2({ user: "0x..." }, (data) => {
      *   console.log(data);
      * });
      * ```
      */
-    webData2(args, listener, signal) {
+    webData2(args, listener) {
         const payload = {
             type: "webData2",
             user: args.user,
         };
-        return this.transport.subscribe(payload.type, payload, (event) => {
-            if (event.detail.user === args.user.toLowerCase()) {
-                listener(event.detail);
+        return this.transport.subscribe(payload.type, payload, (e) => {
+            if (e.detail.user === args.user.toLowerCase()) {
+                listener(e.detail);
             }
-        }, signal);
+        });
     }
     async [Symbol.asyncDispose]() {
         await this.transport[Symbol.asyncDispose]?.();