@nktkas/hyperliquid 0.19.2 → 0.21.0

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

@@ -9,12 +9,13 @@
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.EventClient = void 0;
+    exports.SubscriptionClient = void 0;
     /**
-     * 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.
      */
-    class EventClient {
+    class SubscriptionClient {
+        transport;
         /**
          * Initialises a new instance.
          * @param args - The arguments for initialisation.
@@ -24,24 +25,16 @@
          * 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
@@ -50,30 +43,29 @@
          * 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
@@ -82,46 +74,40 @@
          * 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
@@ -130,29 +116,28 @@
          * 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
@@ -161,29 +146,28 @@
          * 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.
          *
@@ -193,26 +177,24 @@
          * 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.
          *
@@ -222,27 +204,25 @@
          * 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
@@ -251,31 +231,30 @@
          * 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
@@ -284,27 +263,26 @@
          * 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
@@ -313,27 +291,26 @@
          * 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
@@ -342,29 +319,28 @@
          * 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.
@@ -375,27 +351,26 @@
          * 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
@@ -404,30 +379,29 @@
          * 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
@@ -436,29 +410,28 @@
          * 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
@@ -467,29 +440,28 @@
          * 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
@@ -498,29 +470,28 @@
          * 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
@@ -529,29 +500,28 @@
          * 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
@@ -560,27 +530,27 @@
          * 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]?.();
         }
     }
-    exports.EventClient = EventClient;
+    exports.SubscriptionClient = SubscriptionClient;
 });