@nktkas/hyperliquid 0.13.1 → 0.13.2

package/script/src/clients/event.js

@@ -1,496 +1,562 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventClient = void 0;
-// ———————————————Client———————————————
-/**
- * Event client for subscribing to various Hyperliquid events.
- * @typeParam T - The type of transport used to connect to the Hyperliquid Websocket API.
- */
-class EventClient {
-    /**
-     * Initialises a new instance.
-     * @param args - The arguments for initialisation.
-     *
-     * @example
-     * ```ts
-     * import * as hl from "@nktkas/hyperliquid";
-     *
-     * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ 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 {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions | Hyperliquid GitBook}
-     * @example
-     * ```ts
-     * import * as hl from "@nktkas/hyperliquid";
-     *
-     * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
-     *
-     * const sub = await client.activeAssetCtx({ coin: "BTC" }, (data) => {
-     *   console.log(data);
-     * });
-     * ```
-     */
-    activeAssetCtx(args, listener, signal) {
-        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);
-            }
-        }, 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 {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions | Hyperliquid GitBook}
-     * @example
-     * ```ts
-     * import * as hl from "@nktkas/hyperliquid";
-     *
-     * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
-     *
-     * const sub = await client.activeAssetData({ coin: "BTC", user: "0x..." }, (data) => {
-     *   console.log(data);
-     * });
-     * ```
-     */
-    activeAssetData(args, listener, signal) {
-        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);
-            }
-        }, signal);
-    }
-    /**
-     * Subscribe to mid prices for all actively traded assets.
-     * @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 {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions | Hyperliquid GitBook}
-     * @example
-     * ```ts
-     * import * as hl from "@nktkas/hyperliquid";
-     *
-     * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
-     *
-     * const sub = await client.allMids((data) => {
-     *   console.log(data);
-     * });
-     * ```
-     */
-    allMids(listener, signal) {
-        const payload = {
-            type: "allMids",
-        };
-        return this.transport.subscribe(payload.type, payload, (event) => {
-            listener(event.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 {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions | Hyperliquid GitBook}
-     * @example
-     * ```ts
-     * import * as hl from "@nktkas/hyperliquid";
-     *
-     * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
-     *
-     * const sub = await client.candle({ coin: "BTC", interval: "1h" }, (data) => {
-     *   console.log(data);
-     * });
-     * ```
-     */
-    candle(args, listener, signal) {
-        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);
-            }
-        }, signal);
-    }
-    /**
-     * 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 {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions | Hyperliquid GitBook}
-     * @example
-     * ```ts
-     * import * as hl from "@nktkas/hyperliquid";
-     *
-     * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
-     *
-     * const sub = await client.l2Book({ coin: "BTC" }, (data) => {
-     *   console.log(data);
-     * });
-     * ```
-     */
-    l2Book(args, listener, signal) {
-        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);
-            }
-        }, 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 {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions | Hyperliquid GitBook}
-     * @example
-     * ```ts
-     * import * as hl from "@nktkas/hyperliquid";
-     *
-     * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
-     *
-     * const sub = await client.notification({ user: "0x..." }, (data) => {
-     *   console.log(data);
-     * });
-     * ```
-     */
-    notification(args, listener, signal) {
-        const payload = {
-            type: "notification",
-            user: args.user,
-        };
-        return this.transport.subscribe(payload.type, payload, (event) => {
-            listener(event.detail);
-        }, signal);
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
     }
-    /**
-     * 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 {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions | Hyperliquid GitBook}
-     * @example
-     * ```ts
-     * import * as hl from "@nktkas/hyperliquid";
-     *
-     * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
-     *
-     * const sub = await client.orderUpdates({ user: "0x..." }, (data) => {
-     *   console.log(data);
-     * });
-     * ```
-     */
-    orderUpdates(args, listener, signal) {
-        const payload = {
-            type: "orderUpdates",
-            user: args.user,
-        };
-        return this.transport.subscribe(payload.type, payload, (event) => {
-            listener(event.detail);
-        }, signal);
-    }
-    /**
-     * 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 {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions | Hyperliquid GitBook}
-     * @example
-     * ```ts
-     * import * as hl from "@nktkas/hyperliquid";
-     *
-     * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
-     *
-     * const sub = await client.trades({ coin: "BTC" }, (data) => {
-     *   console.log(data);
-     * });
-     * ```
-     */
-    trades(args, listener, signal) {
-        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);
-            }
-        }, signal);
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
     }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.EventClient = void 0;
+    // ——————————————— Client ———————————————
     /**
-     * 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.
-     *
-     * @see {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions | Hyperliquid GitBook}
-     * @example
-     * ```ts
-     * import * as hl from "@nktkas/hyperliquid";
-     *
-     * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
-     *
-     * const sub = await client.userEvents({ user: "0x..." }, (data) => {
-     *   console.log(data);
-     * });
-     * ```
+     * Event client for subscribing to various Hyperliquid events.
+     * @typeParam T - The type of transport used to connect to the Hyperliquid Websocket API.
      */
-    userEvents(args, listener, signal) {
-        const payload = {
-            type: "userEvents",
-            user: args.user,
-        };
-        return this.transport.subscribe(payload.type, payload, (event) => {
-            listener(event.detail);
-        }, signal);
-    }
-    /**
-     * 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 {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions | Hyperliquid GitBook}
-     * @example
-     * ```ts
-     * import * as hl from "@nktkas/hyperliquid";
-     *
-     * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
-     *
-     * const sub = await client.userFills({ user: "0x..." }, (data) => {
-     *   console.log(data);
-     * });
-     * ```
-     */
-    userFills(args, listener, signal) {
-        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()) {
+    class EventClient {
+        /**
+         * Initialises a new instance.
+         * @param args - The arguments for initialisation.
+         *
+         * @example
+         * ```ts
+         * import * as hl from "@nktkas/hyperliquid";
+         *
+         * const transport = new hl.WebSocketTransport();
+         * const client = new hl.EventClient({ 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
+         * @example
+         * ```ts
+         * import * as hl from "@nktkas/hyperliquid";
+         *
+         * const transport = new hl.WebSocketTransport();
+         * const client = new hl.EventClient({ transport });
+         *
+         * const sub = await client.activeAssetCtx({ coin: "BTC" }, (data) => {
+         *   console.log(data);
+         * });
+         * ```
+         */
+        activeAssetCtx(args, listener, signal) {
+            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);
+                }
+            }, 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
+         * @example
+         * ```ts
+         * import * as hl from "@nktkas/hyperliquid";
+         *
+         * const transport = new hl.WebSocketTransport();
+         * const client = new hl.EventClient({ transport });
+         *
+         * const sub = await client.activeAssetData({ coin: "BTC", user: "0x..." }, (data) => {
+         *   console.log(data);
+         * });
+         * ```
+         */
+        activeAssetData(args, listener, signal) {
+            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);
+                }
+            }, signal);
+        }
+        /**
+         * Subscribe to mid prices for all actively traded assets.
+         * @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
+         * @example
+         * ```ts
+         * import * as hl from "@nktkas/hyperliquid";
+         *
+         * const transport = new hl.WebSocketTransport();
+         * const client = new hl.EventClient({ transport });
+         *
+         * const sub = await client.allMids((data) => {
+         *   console.log(data);
+         * });
+         * ```
+         */
+        allMids(listener, signal) {
+            const payload = {
+                type: "allMids",
+            };
+            return this.transport.subscribe(payload.type, payload, (event) => {
                 listener(event.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 {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions | Hyperliquid GitBook}
-     * @example
-     * ```ts
-     * import * as hl from "@nktkas/hyperliquid";
-     *
-     * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
-     *
-     * const sub = await client.userFundings({ user: "0x..." }, (data) => {
-     *   console.log(data);
-     * });
-     * ```
-     */
-    userFundings(args, listener, signal) {
-        const payload = {
-            type: "userFundings",
-            user: args.user,
-        };
-        return this.transport.subscribe(payload.type, payload, (event) => {
-            if (event.detail.user === args.user.toLowerCase()) {
+            }, 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
+         * @example
+         * ```ts
+         * import * as hl from "@nktkas/hyperliquid";
+         *
+         * const transport = new hl.WebSocketTransport();
+         * const client = new hl.EventClient({ transport });
+         *
+         * const sub = await client.candle({ coin: "BTC", interval: "1h" }, (data) => {
+         *   console.log(data);
+         * });
+         * ```
+         */
+        candle(args, listener, signal) {
+            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);
+                }
+            }, 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.
+         *
+         * @see null - no documentation
+         * @example
+         * ```ts
+         * import * as hl from "@nktkas/hyperliquid";
+         *
+         * const transport = new hl.WebSocketTransport();
+         * const client = new hl.EventClient({ transport });
+         *
+         * const sub = await client.explorerBlock((data) => {
+         *   console.log(data);
+         * });
+         * ```
+         */
+        explorerBlock(listener, signal) {
+            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);
-    }
-    /**
-     * 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 {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions | Hyperliquid GitBook}
-     * @example
-     * ```ts
-     * import * as hl from "@nktkas/hyperliquid";
-     *
-     * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
-     *
-     * const sub = await client.userNonFundingLedgerUpdates({ user: "0x..." }, (data) => {
-     *   console.log(data);
-     * });
-     * ```
-     */
-    userNonFundingLedgerUpdates(args, listener, signal) {
-        const payload = {
-            type: "userNonFundingLedgerUpdates",
-            user: args.user,
-        };
-        return this.transport.subscribe(payload.type, payload, (event) => {
-            if (event.detail.user === args.user.toLowerCase()) {
+            }, signal);
+        }
+        /**
+         * 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.
+         *
+         * @see null - no documentation
+         * @example
+         * ```ts
+         * import * as hl from "@nktkas/hyperliquid";
+         *
+         * const transport = new hl.WebSocketTransport();
+         * const client = new hl.EventClient({ transport });
+         *
+         * const sub = await client.explorerTxs((data) => {
+         *   console.log(data);
+         * });
+         * ```
+         */
+        explorerTxs(listener, signal) {
+            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);
-    }
-    /**
-     * 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 {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions | Hyperliquid GitBook}
-     * @example
-     * ```ts
-     * import * as hl from "@nktkas/hyperliquid";
-     *
-     * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
-     *
-     * const sub = await client.userTwapHistory({ user: "0x..." }, (data) => {
-     *   console.log(data);
-     * });
-     * ```
-     */
-    userTwapHistory(args, listener, signal) {
-        const payload = {
-            type: "userTwapHistory",
-            user: args.user,
-        };
-        return this.transport.subscribe(payload.type, payload, (event) => {
-            if (event.detail.user === args.user.toLowerCase()) {
+            }, signal);
+        }
+        /**
+         * 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
+         * @example
+         * ```ts
+         * import * as hl from "@nktkas/hyperliquid";
+         *
+         * const transport = new hl.WebSocketTransport();
+         * const client = new hl.EventClient({ transport });
+         *
+         * const sub = await client.l2Book({ coin: "BTC" }, (data) => {
+         *   console.log(data);
+         * });
+         * ```
+         */
+        l2Book(args, listener, signal) {
+            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);
+                }
+            }, 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
+         * @example
+         * ```ts
+         * import * as hl from "@nktkas/hyperliquid";
+         *
+         * const transport = new hl.WebSocketTransport();
+         * const client = new hl.EventClient({ transport });
+         *
+         * const sub = await client.notification({ user: "0x..." }, (data) => {
+         *   console.log(data);
+         * });
+         * ```
+         */
+        notification(args, listener, signal) {
+            const payload = {
+                type: "notification",
+                user: args.user,
+            };
+            return this.transport.subscribe(payload.type, payload, (event) => {
                 listener(event.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 {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions | Hyperliquid GitBook}
-     * @example
-     * ```ts
-     * import * as hl from "@nktkas/hyperliquid";
-     *
-     * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
-     *
-     * const sub = await client.userTwapSliceFills({ user: "0x..." }, (data) => {
-     *   console.log(data);
-     * });
-     * ```
-     */
-    userTwapSliceFills(args, listener, signal) {
-        const payload = {
-            type: "userTwapSliceFills",
-            user: args.user,
-        };
-        return this.transport.subscribe(payload.type, payload, (event) => {
-            if (event.detail.user === args.user.toLowerCase()) {
+            }, signal);
+        }
+        /**
+         * 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
+         * @example
+         * ```ts
+         * import * as hl from "@nktkas/hyperliquid";
+         *
+         * const transport = new hl.WebSocketTransport();
+         * const client = new hl.EventClient({ transport });
+         *
+         * const sub = await client.orderUpdates({ user: "0x..." }, (data) => {
+         *   console.log(data);
+         * });
+         * ```
+         */
+        orderUpdates(args, listener, signal) {
+            const payload = {
+                type: "orderUpdates",
+                user: args.user,
+            };
+            return this.transport.subscribe(payload.type, payload, (event) => {
                 listener(event.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 {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions | Hyperliquid GitBook}
-     * @example
-     * ```ts
-     * import * as hl from "@nktkas/hyperliquid";
-     *
-     * const transport = new hl.WebSocketTransport();
-     * const client = new hl.EventClient({ transport });
-     *
-     * const sub = await client.webData2({ user: "0x..." }, (data) => {
-     *   console.log(data);
-     * });
-     * ```
-     */
-    webData2(args, listener, signal) {
-        const payload = {
-            type: "webData2",
-            user: args.user,
-        };
-        return this.transport.subscribe(payload.type, payload, (event) => {
-            if (event.detail.user === args.user.toLowerCase()) {
+            }, signal);
+        }
+        /**
+         * 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
+         * @example
+         * ```ts
+         * import * as hl from "@nktkas/hyperliquid";
+         *
+         * const transport = new hl.WebSocketTransport();
+         * const client = new hl.EventClient({ transport });
+         *
+         * const sub = await client.trades({ coin: "BTC" }, (data) => {
+         *   console.log(data);
+         * });
+         * ```
+         */
+        trades(args, listener, signal) {
+            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);
+                }
+            }, 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.
+         *
+         * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
+         * @example
+         * ```ts
+         * import * as hl from "@nktkas/hyperliquid";
+         *
+         * const transport = new hl.WebSocketTransport();
+         * const client = new hl.EventClient({ transport });
+         *
+         * const sub = await client.userEvents({ user: "0x..." }, (data) => {
+         *   console.log(data);
+         * });
+         * ```
+         */
+        userEvents(args, listener, signal) {
+            const payload = {
+                type: "userEvents",
+                user: args.user,
+            };
+            return this.transport.subscribe(payload.type, payload, (event) => {
                 listener(event.detail);
-            }
-        }, signal);
+            }, signal);
+        }
+        /**
+         * 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
+         * @example
+         * ```ts
+         * import * as hl from "@nktkas/hyperliquid";
+         *
+         * const transport = new hl.WebSocketTransport();
+         * const client = new hl.EventClient({ transport });
+         *
+         * const sub = await client.userFills({ user: "0x..." }, (data) => {
+         *   console.log(data);
+         * });
+         * ```
+         */
+        userFills(args, listener, signal) {
+            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);
+                }
+            }, 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
+         * @example
+         * ```ts
+         * import * as hl from "@nktkas/hyperliquid";
+         *
+         * const transport = new hl.WebSocketTransport();
+         * const client = new hl.EventClient({ transport });
+         *
+         * const sub = await client.userFundings({ user: "0x..." }, (data) => {
+         *   console.log(data);
+         * });
+         * ```
+         */
+        userFundings(args, listener, signal) {
+            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);
+                }
+            }, 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
+         * @example
+         * ```ts
+         * import * as hl from "@nktkas/hyperliquid";
+         *
+         * const transport = new hl.WebSocketTransport();
+         * const client = new hl.EventClient({ transport });
+         *
+         * const sub = await client.userNonFundingLedgerUpdates({ user: "0x..." }, (data) => {
+         *   console.log(data);
+         * });
+         * ```
+         */
+        userNonFundingLedgerUpdates(args, listener, signal) {
+            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);
+                }
+            }, 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
+         * @example
+         * ```ts
+         * import * as hl from "@nktkas/hyperliquid";
+         *
+         * const transport = new hl.WebSocketTransport();
+         * const client = new hl.EventClient({ transport });
+         *
+         * const sub = await client.userTwapHistory({ user: "0x..." }, (data) => {
+         *   console.log(data);
+         * });
+         * ```
+         */
+        userTwapHistory(args, listener, signal) {
+            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);
+                }
+            }, 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
+         * @example
+         * ```ts
+         * import * as hl from "@nktkas/hyperliquid";
+         *
+         * const transport = new hl.WebSocketTransport();
+         * const client = new hl.EventClient({ transport });
+         *
+         * const sub = await client.userTwapSliceFills({ user: "0x..." }, (data) => {
+         *   console.log(data);
+         * });
+         * ```
+         */
+        userTwapSliceFills(args, listener, signal) {
+            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);
+                }
+            }, 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
+         * @example
+         * ```ts
+         * import * as hl from "@nktkas/hyperliquid";
+         *
+         * const transport = new hl.WebSocketTransport();
+         * const client = new hl.EventClient({ transport });
+         *
+         * const sub = await client.webData2({ user: "0x..." }, (data) => {
+         *   console.log(data);
+         * });
+         * ```
+         */
+        webData2(args, listener, signal) {
+            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);
+                }
+            }, signal);
+        }
     }
-}
-exports.EventClient = EventClient;
+    exports.EventClient = EventClient;
+});