@pear-protocol/hyperliquid-sdk 0.0.4 → 0.0.5

package/dist/index.esm.js

@@ -1,5 +1,5 @@
 import axios from 'axios';
-import require$$0, { createContext, useMemo, useState, useEffect, useContext } from 'react';
+import require$$0, { createContext, useMemo, useState, useEffect, useContext, useCallback } from 'react';
 import require$$1 from 'react-dom';
 
 /**
@@ -203,6 +203,2890 @@ class PearMigrationSDK {
     }
 }
 
+/** Base error class for all SDK errors. */
+class HyperliquidError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "HyperliquidError";
+    }
+}
+
+/** Base class for all transport-related errors. */
+class TransportError extends HyperliquidError {
+    constructor(message) {
+        super(message);
+        this.name = "TransportError";
+    }
+}
+
+/**
+ * Info client for interacting with the Hyperliquid API.
+ * @typeParam T The type of transport used to connect to the Hyperliquid API.
+ */
+class InfoClient {
+    transport;
+    /**
+     * Initialises a new instance.
+     * @param args - The arguments for initialisation.
+     *
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     * ```
+     */
+    constructor(args) {
+        this.transport = args.transport;
+    }
+    allMids(args_or_signal, maybeSignal) {
+        const args = args_or_signal instanceof AbortSignal ? {} : args_or_signal;
+        const signal = args_or_signal instanceof AbortSignal ? args_or_signal : maybeSignal;
+        const request = {
+            type: "allMids",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Block details by block height.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Block details response.
+     *
+     * @see null - no documentation
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.blockDetails({ height: 123 });
+     * ```
+     */
+    async blockDetails(args, signal) {
+        const request = {
+            type: "blockDetails",
+            ...args,
+        };
+        const { blockDetails } = await this.transport.request("explorer", request, signal);
+        return blockDetails;
+    }
+    /**
+     * Request candlestick snapshots.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Array of candlestick data points.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#candle-snapshot
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.candleSnapshot({
+     *   coin: "ETH",
+     *   interval: "1h",
+     *   startTime: Date.now() - 1000 * 60 * 60 * 24
+     * });
+     * ```
+     */
+    candleSnapshot(args, signal) {
+        const request = {
+            type: "candleSnapshot",
+            req: args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request clearinghouse state.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Account summary for perpetual trading.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/perpetuals#retrieve-users-perpetuals-account-summary
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.clearinghouseState({ user: "0x..." });
+     * ```
+     */
+    clearinghouseState(args, signal) {
+        const request = {
+            type: "clearinghouseState",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request user staking delegations.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Array of user's delegations to validators.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#query-a-users-staking-delegations
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.delegations({ user: "0x..." });
+     * ```
+     */
+    delegations(args, signal) {
+        const request = {
+            type: "delegations",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request user staking history.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Array of user's staking updates.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#query-a-users-staking-history
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.delegatorHistory({ user: "0x..." });
+     * ```
+     */
+    delegatorHistory(args, signal) {
+        const request = {
+            type: "delegatorHistory",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request user staking rewards.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Array of user's staking rewards.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#query-a-users-staking-rewards
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.delegatorRewards({ user: "0x..." });
+     * ```
+     */
+    delegatorRewards(args, signal) {
+        const request = {
+            type: "delegatorRewards",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request user staking summary.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Summary of a user's staking delegations.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#query-a-users-staking-summary
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.delegatorSummary({ user: "0x..." });
+     * ```
+     */
+    delegatorSummary(args, signal) {
+        const request = {
+            type: "delegatorSummary",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request user's extra agents.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns User's extra agents.
+     *
+     * @see null - no documentation
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.extraAgents({ user: "0x..." });
+     * ```
+     */
+    extraAgents(args, signal) {
+        const request = {
+            type: "extraAgents",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request frontend open orders.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Array of open orders with additional frontend information.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#retrieve-a-users-open-orders-with-additional-frontend-info
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.frontendOpenOrders({ user: "0x..." });
+     * ```
+     */
+    frontendOpenOrders(args, signal) {
+        const request = {
+            type: "frontendOpenOrders",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request funding history.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Array of historical funding rate data for an asset.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/perpetuals#retrieve-historical-funding-rates
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.fundingHistory({
+     *   coin: "ETH",
+     *   startTime: Date.now() - 1000 * 60 * 60 * 24
+     * });
+     * ```
+     */
+    fundingHistory(args, signal) {
+        const request = {
+            type: "fundingHistory",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request user's historical orders.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Array of user's historical orders.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#retrieve-a-users-historical-orders
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.historicalOrders({ user: "0x..." });
+     * ```
+     */
+    historicalOrders(args, signal) {
+        const request = {
+            type: "historicalOrders",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request to check if a user is a VIP.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Boolean indicating user's VIP status.
+     *
+     * @see null - no documentation
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.isVip({ user: "0x..." });
+     * ```
+     */
+    isVip(args, signal) {
+        const request = {
+            type: "isVip",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request L2 order book.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns L2 order book snapshot.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#l2-book-snapshot
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.l2Book({ coin: "ETH", nSigFigs: 2 });
+     * ```
+     */
+    l2Book(args, signal) {
+        const request = {
+            type: "l2Book",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request legal verification status of a user.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Legal verification status for a user.
+     *
+     * @see null - no documentation
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.legalCheck({ user: "0x..." });
+     * ```
+     */
+    legalCheck(args, signal) {
+        const request = {
+            type: "legalCheck",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request builder fee approval.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Maximum builder fee approval.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#check-builder-fee-approval
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.maxBuilderFee({ user: "0x...", builder: "0x..." });
+     * ```
+     */
+    maxBuilderFee(args, signal) {
+        const request = {
+            type: "maxBuilderFee",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    meta(args_or_signal, maybeSignal) {
+        const args = args_or_signal instanceof AbortSignal ? {} : args_or_signal;
+        const signal = args_or_signal instanceof AbortSignal ? args_or_signal : maybeSignal;
+        const request = {
+            type: "meta",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request metadata and asset contexts.
+     * @param signal - An optional abort signal.
+     * @returns Metadata and context information for each perpetual asset.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/perpetuals#retrieve-perpetuals-asset-contexts-includes-mark-price-current-funding-open-interest-etc
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.metaAndAssetCtxs();
+     * ```
+     */
+    metaAndAssetCtxs(signal) {
+        const request = {
+            type: "metaAndAssetCtxs",
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request open orders.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Array of open order.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#retrieve-a-users-open-orders
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.openOrders({ user: "0x..." });
+     * ```
+     */
+    openOrders(args, signal) {
+        const request = {
+            type: "openOrders",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request order status.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Result of an order status lookup.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#query-order-status-by-oid-or-cloid
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.orderStatus({ user: "0x...", oid: 12345 });
+     * ```
+     */
+    orderStatus(args, signal) {
+        const request = {
+            type: "orderStatus",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request for the status of the perpetual deploy auction.
+     * @param signal - An optional abort signal.
+     * @returns Status of the perpetual deploy auction.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/perpetuals#retrieve-information-about-the-perp-deploy-auction
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.perpDeployAuctionStatus();
+     * ```
+     */
+    perpDeployAuctionStatus(signal) {
+        const request = {
+            type: "perpDeployAuctionStatus",
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request all perpetual dexs.
+     * @param signal - An optional abort signal.
+     * @returns Array of perpetual dexes.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/perpetuals#retrieve-all-perpetual-dexs
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.perpDexs();
+     * ```
+     */
+    perpDexs(signal) {
+        const request = {
+            type: "perpDexs",
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request perpetuals at open interest cap.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Array of perpetuals at open interest caps.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/perpetuals#query-perps-at-open-interest-caps
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.perpsAtOpenInterestCap();
+     * ```
+     */
+    perpsAtOpenInterestCap(signal) {
+        const request = {
+            type: "perpsAtOpenInterestCap",
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request portfolio.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Portfolio of a user.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#query-a-users-portfolio
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.portfolio({ user: "0x..." });
+     * ```
+     */
+    portfolio(args, signal) {
+        const request = {
+            type: "portfolio",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request predicted funding rates.
+     * @param signal - An optional abort signal.
+     * @returns Array of predicted funding rates.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/perpetuals#retrieve-predicted-funding-rates-for-different-venues
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.predictedFundings();
+     * ```
+     */
+    predictedFundings(signal) {
+        const request = {
+            type: "predictedFundings",
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request user's existence check before transfer.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Pre-transfer user existence check result.
+     *
+     * @see null - no documentation
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.preTransferCheck({ user: "0x...", source: "0x..." });
+     * ```
+     */
+    preTransferCheck(args, signal) {
+        const request = {
+            type: "preTransferCheck",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request user referral.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Referral information for a user.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#query-a-users-referral-information
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.referral({ user: "0x..." });
+     * ```
+     */
+    referral(args, signal) {
+        const request = {
+            type: "referral",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request spot clearinghouse state.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Balances for spot tokens.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/spot#retrieve-a-users-token-balances
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.spotClearinghouseState({ user: "0x..." });
+     * ```
+     */
+    spotClearinghouseState(args, signal) {
+        const request = {
+            type: "spotClearinghouseState",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request spot deploy state.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns The deploy state of a user.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/spot#retrieve-information-about-the-spot-deploy-auction
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.spotDeployState({ user: "0x..." });
+     * ```
+     */
+    spotDeployState(args, signal) {
+        const request = {
+            type: "spotDeployState",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request spot trading metadata.
+     * @param signal - An optional abort signal.
+     * @returns Metadata for spot assets.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/spot#retrieve-spot-metadata
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.spotMeta();
+     * ```
+     */
+    spotMeta(signal) {
+        const request = {
+            type: "spotMeta",
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request spot metadata and asset contexts.
+     * @param signal - An optional abort signal.
+     * @returns Metadata and context information for each spot asset.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/spot#retrieve-spot-asset-contexts
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.spotMetaAndAssetCtxs();
+     * ```
+     */
+    spotMetaAndAssetCtxs(signal) {
+        const request = {
+            type: "spotMetaAndAssetCtxs",
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request user sub-accounts.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Array of user sub-account or null if the user does not have any sub-accounts.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#retrieve-a-users-subaccounts
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.subAccounts({ user: "0x..." });
+     * ```
+     */
+    subAccounts(args, signal) {
+        const request = {
+            type: "subAccounts",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request token details.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns The details of a token.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/spot#retrieve-information-about-a-token
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.tokenDetails({ tokenId: "0x..." });
+     * ```
+     */
+    tokenDetails(args, signal) {
+        const request = {
+            type: "tokenDetails",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request twap history of a user.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns The twap history of a user.
+     *
+     * @see null - no documentation
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.twapHistory({ user: "0x..." });
+     * ```
+     */
+    twapHistory(args, signal) {
+        const request = {
+            type: "twapHistory",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Transaction details by transaction hash.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Transaction details response.
+     *
+     * @see null - no documentation
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.txDetails({ hash: "0x..." });
+     * ```
+     */
+    async txDetails(args, signal) {
+        const request = {
+            type: "txDetails",
+            ...args,
+        };
+        const { tx } = await this.transport.request("explorer", request, signal);
+        return tx;
+    }
+    /**
+     * User details by user's address.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns User details response.
+     *
+     * @see null - no documentation
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.userDetails({ user: "0x..." });
+     * ```
+     */
+    async userDetails(args, signal) {
+        const request = {
+            type: "userDetails",
+            ...args,
+        };
+        const { txs } = await this.transport.request("explorer", request, signal);
+        return txs;
+    }
+    /**
+     * Request user fees.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns User fees.
+     *
+     * @see null - no documentation
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.userFees({ user: "0x..." });
+     * ```
+     */
+    userFees(args, signal) {
+        const request = {
+            type: "userFees",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request user fills.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Array of user's trade fill.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#retrieve-a-users-fills
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.userFills({ user: "0x..." });
+     * ```
+     */
+    userFills(args, signal) {
+        const request = {
+            type: "userFills",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request user fills by time.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Array of user's trade fill.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#retrieve-a-users-fills-by-time
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.userFillsByTime({
+     *   user: "0x...",
+     *   startTime: Date.now() - 1000 * 60 * 60 * 24
+     * });
+     * ```
+     */
+    userFillsByTime(args, signal) {
+        const request = {
+            type: "userFillsByTime",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request user funding.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Array of user's funding ledger update.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/perpetuals#retrieve-a-users-funding-history-or-non-funding-ledger-updates
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.userFunding({
+     *   user: "0x...",
+     *   startTime: Date.now() - 1000 * 60 * 60 * 24
+     * });
+     * ```
+     */
+    userFunding(args, signal) {
+        const request = {
+            type: "userFunding",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request user non-funding ledger updates.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Array of user's non-funding ledger update.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/perpetuals#retrieve-a-users-funding-history-or-non-funding-ledger-updates
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.userNonFundingLedgerUpdates({
+     *   user: "0x...",
+     *   startTime: Date.now() - 1000 * 60 * 60 * 24
+     * });
+     * ```
+     */
+    userNonFundingLedgerUpdates(args, signal) {
+        const request = {
+            type: "userNonFundingLedgerUpdates",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request user rate limits.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns User's rate limits.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#query-user-rate-limits
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.userRateLimit({ user: "0x..." });
+     * ```
+     */
+    userRateLimit(args, signal) {
+        const request = {
+            type: "userRateLimit",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request user role.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns User's role.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#query-a-users-role
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.userRole({ user: "0x..." });
+     * ```
+     */
+    userRole(args, signal) {
+        const request = {
+            type: "userRole",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request multi-sig signers for a user.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Multi-sig signers for a user or null if the user does not have any multi-sig signers.
+     *
+     * @see null - no documentation
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.userToMultiSigSigners({ user: "0x..." });
+     * ```
+     */
+    userToMultiSigSigners(args, signal) {
+        const request = {
+            type: "userToMultiSigSigners",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request user twap slice fills.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Array of user's twap slice fill.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#retrieve-a-users-twap-slice-fills
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.userTwapSliceFills({ user: "0x..." });
+     * ```
+     */
+    userTwapSliceFills(args, signal) {
+        const request = {
+            type: "userTwapSliceFills",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request user twap slice fills by time.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Array of user's twap slice fill.
+     *
+     * @see null - no documentation
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.userTwapSliceFillsByTime({
+     *   user: "0x...",
+     *   startTime: Date.now() - 1000 * 60 * 60 * 24
+     * });
+     * ```
+     */
+    userTwapSliceFillsByTime(args, signal) {
+        const request = {
+            type: "userTwapSliceFillsByTime",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request user vault deposits.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Array of user's vault deposits.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#retrieve-a-users-vault-deposits
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.userVaultDeposits({ user: "0x..." });
+     * ```
+     */
+    userVaultEquities(args, signal) {
+        const request = {
+            type: "userVaultEquities",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request validator summaries.
+     * @param args - The parameters for the request.
+     * @returns Array of validator summaries.
+     *
+     * @see null - no documentation
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.validatorSummaries();
+     * ```
+     */
+    validatorSummaries(signal) {
+        const request = {
+            type: "validatorSummaries",
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request details of a vault.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Details of a vault or null if the vault does not exist.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#retrieve-details-for-a-vault
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.vaultDetails({ vaultAddress: "0x..." });
+     * ```
+     */
+    vaultDetails(args, signal) {
+        const request = {
+            type: "vaultDetails",
+            ...args,
+        };
+        return this.transport.request("info", request, signal);
+    }
+    /**
+     * Request a list of vaults less than 2 hours old.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Array of vault summaries.
+     *
+     * @see null - no documentation
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.vaultSummaries();
+     * ```
+     */
+    vaultSummaries(signal) {
+        const request = {
+            type: "vaultSummaries",
+        };
+        return this.transport.request("info", request, signal);
+    }
+    async [Symbol.asyncDispose]() {
+        await this.transport[Symbol.asyncDispose]?.();
+    }
+}
+
+/**
+ * Subscription client for subscribing to various Hyperliquid events.
+ * @typeParam T The type of transport used to connect to the Hyperliquid Websocket API.
+ */
+class SubscriptionClient {
+    transport;
+    /**
+     * Initialises a new instance.
+     * @param args - The arguments for initialisation.
+     *
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.WebSocketTransport();
+     * const subsClient = new hl.SubscriptionClient({ transport });
+     * ```
+     */
+    constructor(args) {
+        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.
+     * @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 subsClient = new hl.SubscriptionClient({ transport });
+     *
+     * const sub = await subsClient.activeAssetCtx({ coin: "BTC" }, (data) => {
+     *   console.log(data);
+     * });
+     * ```
+     */
+    activeAssetCtx(args, listener) {
+        const channel = args.coin.startsWith("@") ? "activeSpotAssetCtx" : "activeAssetCtx";
+        const payload = {
+            type: "activeAssetCtx",
+            coin: args.coin,
+        };
+        return this.transport.subscribe(channel, payload, (e) => {
+            if (e.detail.coin === args.coin) {
+                listener(e.detail);
+            }
+        });
+    }
+    /**
+     * 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.
+     * @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 subsClient = new hl.SubscriptionClient({ transport });
+     *
+     * const sub = await subsClient.activeAssetData({ coin: "BTC", user: "0x..." }, (data) => {
+     *   console.log(data);
+     * });
+     * ```
+     */
+    activeAssetData(args, listener) {
+        const payload = {
+            type: "activeAssetData",
+            coin: args.coin,
+            user: args.user,
+        };
+        return this.transport.subscribe(payload.type, payload, (e) => {
+            if (e.detail.coin === args.coin && e.detail.user === args.user.toLowerCase()) {
+                listener(e.detail);
+            }
+        });
+    }
+    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 : maybeListener;
+        const payload = {
+            type: "allMids",
+            dex: args.dex,
+        };
+        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.
+     * @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 subsClient = new hl.SubscriptionClient({ transport });
+     *
+     * const sub = await subsClient.bbo({ coin: "BTC" }, (data) => {
+     *   console.log(data);
+     * });
+     * ```
+     */
+    bbo(args, listener) {
+        const payload = {
+            type: "bbo",
+            coin: args.coin,
+        };
+        return this.transport.subscribe(payload.type, payload, (e) => {
+            if (e.detail.coin === args.coin) {
+                listener(e.detail);
+            }
+        });
+    }
+    /**
+     * 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.
+     * @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 subsClient = new hl.SubscriptionClient({ transport });
+     *
+     * const sub = await subsClient.candle({ coin: "BTC", interval: "1h" }, (data) => {
+     *   console.log(data);
+     * });
+     * ```
+     */
+    candle(args, listener) {
+        const payload = {
+            type: "candle",
+            coin: args.coin,
+            interval: args.interval,
+        };
+        return this.transport.subscribe(payload.type, payload, (e) => {
+            if (e.detail.s === args.coin && e.detail.i === args.interval) {
+                listener(e.detail);
+            }
+        });
+    }
+    /**
+     * Subscribe to explorer block updates.
+     * @param listener - The callback function to be called when the event is received.
+     * @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.
+     *
+     * @see null - no documentation
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.WebSocketTransport();
+     * const subsClient = new hl.SubscriptionClient({ transport });
+     *
+     * const sub = await subsClient.explorerBlock((data) => {
+     *   console.log(data);
+     * });
+     * ```
+     */
+    explorerBlock(listener) {
+        const payload = {
+            type: "explorerBlock",
+        };
+        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.
+     * @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.
+     *
+     * @see null - no documentation
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.WebSocketTransport();
+     * const subsClient = new hl.SubscriptionClient({ transport });
+     *
+     * const sub = await subsClient.explorerTxs((data) => {
+     *   console.log(data);
+     * });
+     * ```
+     */
+    explorerTxs(listener) {
+        const payload = {
+            type: "explorerTxs",
+        };
+        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.
+     * @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 subsClient = new hl.SubscriptionClient({ transport });
+     *
+     * const sub = await subsClient.l2Book({ coin: "BTC" }, (data) => {
+     *   console.log(data);
+     * });
+     * ```
+     */
+    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, (e) => {
+            if (e.detail.coin === args.coin) {
+                listener(e.detail);
+            }
+        });
+    }
+    /**
+     * 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.
+     * @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 subsClient = new hl.SubscriptionClient({ transport });
+     *
+     * const sub = await subsClient.notification({ user: "0x..." }, (data) => {
+     *   console.log(data);
+     * });
+     * ```
+     */
+    notification(args, listener) {
+        const payload = {
+            type: "notification",
+            user: args.user,
+        };
+        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.
+     * @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 subsClient = new hl.SubscriptionClient({ transport });
+     *
+     * const sub = await subsClient.orderUpdates({ user: "0x..." }, (data) => {
+     *   console.log(data);
+     * });
+     * ```
+     */
+    orderUpdates(args, listener) {
+        const payload = {
+            type: "orderUpdates",
+            user: args.user,
+        };
+        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.
+     * @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 subsClient = new hl.SubscriptionClient({ transport });
+     *
+     * const sub = await subsClient.trades({ coin: "BTC" }, (data) => {
+     *   console.log(data);
+     * });
+     * ```
+     */
+    trades(args, listener) {
+        const payload = {
+            type: "trades",
+            coin: args.coin,
+        };
+        return this.transport.subscribe(payload.type, payload, (e) => {
+            if (e.detail[0]?.coin === args.coin) {
+                listener(e.detail);
+            }
+        });
+    }
+    /**
+     * 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.
+     * @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 subsClient = new hl.SubscriptionClient({ transport });
+     *
+     * const sub = await subsClient.userEvents({ user: "0x..." }, (data) => {
+     *   console.log(data);
+     * });
+     * ```
+     */
+    userEvents(args, listener) {
+        const payload = {
+            type: "userEvents",
+            user: args.user,
+        };
+        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.
+     * @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 subsClient = new hl.SubscriptionClient({ transport });
+     *
+     * const sub = await subsClient.userFills({ user: "0x..." }, (data) => {
+     *   console.log(data);
+     * });
+     * ```
+     */
+    userFills(args, listener) {
+        const payload = {
+            type: "userFills",
+            user: args.user,
+            aggregateByTime: args.aggregateByTime ?? false,
+        };
+        return this.transport.subscribe(payload.type, payload, (e) => {
+            if (e.detail.user === args.user.toLowerCase()) {
+                listener(e.detail);
+            }
+        });
+    }
+    /**
+     * 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.
+     * @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 subsClient = new hl.SubscriptionClient({ transport });
+     *
+     * const sub = await subsClient.userFundings({ user: "0x..." }, (data) => {
+     *   console.log(data);
+     * });
+     * ```
+     */
+    userFundings(args, listener) {
+        const payload = {
+            type: "userFundings",
+            user: args.user,
+        };
+        return this.transport.subscribe(payload.type, payload, (e) => {
+            if (e.detail.user === args.user.toLowerCase()) {
+                listener(e.detail);
+            }
+        });
+    }
+    /**
+     * 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.
+     * @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 subsClient = new hl.SubscriptionClient({ transport });
+     *
+     * const sub = await subsClient.userNonFundingLedgerUpdates({ user: "0x..." }, (data) => {
+     *   console.log(data);
+     * });
+     * ```
+     */
+    userNonFundingLedgerUpdates(args, listener) {
+        const payload = {
+            type: "userNonFundingLedgerUpdates",
+            user: args.user,
+        };
+        return this.transport.subscribe(payload.type, payload, (e) => {
+            if (e.detail.user === args.user.toLowerCase()) {
+                listener(e.detail);
+            }
+        });
+    }
+    /**
+     * 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.
+     * @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 subsClient = new hl.SubscriptionClient({ transport });
+     *
+     * const sub = await subsClient.userTwapHistory({ user: "0x..." }, (data) => {
+     *   console.log(data);
+     * });
+     * ```
+     */
+    userTwapHistory(args, listener) {
+        const payload = {
+            type: "userTwapHistory",
+            user: args.user,
+        };
+        return this.transport.subscribe(payload.type, payload, (e) => {
+            if (e.detail.user === args.user.toLowerCase()) {
+                listener(e.detail);
+            }
+        });
+    }
+    /**
+     * 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.
+     * @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 subsClient = new hl.SubscriptionClient({ transport });
+     *
+     * const sub = await subsClient.userTwapSliceFills({ user: "0x..." }, (data) => {
+     *   console.log(data);
+     * });
+     * ```
+     */
+    userTwapSliceFills(args, listener) {
+        const payload = {
+            type: "userTwapSliceFills",
+            user: args.user,
+        };
+        return this.transport.subscribe(payload.type, payload, (e) => {
+            if (e.detail.user === args.user.toLowerCase()) {
+                listener(e.detail);
+            }
+        });
+    }
+    /**
+     * 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.
+     * @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 subsClient = new hl.SubscriptionClient({ transport });
+     *
+     * const sub = await subsClient.webData2({ user: "0x..." }, (data) => {
+     *   console.log(data);
+     * });
+     * ```
+     */
+    webData2(args, listener) {
+        const payload = {
+            type: "webData2",
+            user: args.user,
+        };
+        return this.transport.subscribe(payload.type, payload, (e) => {
+            if (e.detail.user === args.user.toLowerCase()) {
+                listener(e.detail);
+            }
+        });
+    }
+    async [Symbol.asyncDispose]() {
+        await this.transport[Symbol.asyncDispose]?.();
+    }
+}
+
+/**
+ * Error thrown when an HTTP response is deemed invalid:
+ * - Non-200 status code
+ * - Unexpected content type
+ */
+class HttpRequestError extends TransportError {
+    response;
+    responseBody;
+    /**
+     * Creates a new HTTP request error.
+     * @param response - The failed HTTP response.
+     * @param responseBody - The raw response body content, if available.
+     */
+    constructor(response, responseBody) {
+        let message = `HTTP request failed: status ${response.status}`;
+        if (responseBody)
+            message += `, body "${responseBody}"`;
+        super(message);
+        this.response = response;
+        this.responseBody = responseBody;
+        this.name = "HttpRequestError";
+    }
+}
+/** HTTP implementation of the REST transport interface. */
+class HttpTransport {
+    isTestnet;
+    timeout;
+    server;
+    fetchOptions;
+    onRequest;
+    onResponse;
+    /**
+     * Creates a new HTTP transport instance.
+     * @param options - Configuration options for the HTTP transport layer.
+     */
+    constructor(options) {
+        this.isTestnet = options?.isTestnet ?? false;
+        this.timeout = options?.timeout === undefined ? 10_000 : options.timeout;
+        this.server = {
+            mainnet: {
+                api: options?.server?.mainnet?.api ?? "https://api.hyperliquid.xyz",
+                rpc: options?.server?.mainnet?.rpc ?? "https://rpc.hyperliquid.xyz",
+            },
+            testnet: {
+                api: options?.server?.testnet?.api ?? "https://api.hyperliquid-testnet.xyz",
+                rpc: options?.server?.testnet?.rpc ?? "https://rpc.hyperliquid-testnet.xyz",
+            },
+        };
+        this.fetchOptions = options?.fetchOptions ?? {};
+        this.onRequest = options?.onRequest;
+        this.onResponse = options?.onResponse;
+    }
+    /**
+     * Sends a request to the Hyperliquid API via fetch.
+     * @param endpoint - The API endpoint to send the request to.
+     * @param payload - The payload to send with the request.
+     * @param signal - An optional abort signal.
+     * @returns A promise that resolves with parsed JSON response body.
+     * @throws {HttpRequestError} - Thrown when an HTTP response is deemed invalid.
+     * @throws May throw {@link https://developer.mozilla.org/en-US/docs/Web/API/Window/fetch#exceptions | fetch errors}.
+     */
+    async request(endpoint, payload, signal) {
+        // Construct a Request
+        const url = new URL(endpoint, this.server[this.isTestnet ? "testnet" : "mainnet"][endpoint === "explorer" ? "rpc" : "api"]);
+        const init = mergeRequestInit({
+            body: JSON.stringify(payload),
+            headers: {
+                "Accept-Encoding": "gzip, deflate, br, zstd",
+                "Content-Type": "application/json",
+            },
+            keepalive: true,
+            method: "POST",
+            signal: this.timeout ? AbortSignal.timeout(this.timeout) : undefined,
+        }, this.fetchOptions, { signal });
+        let request = new Request(url, init);
+        // Call the onRequest callback, if provided
+        if (this.onRequest) {
+            const customRequest = await this.onRequest(request);
+            if (customRequest instanceof Request)
+                request = customRequest;
+        }
+        // Send the Request and wait for a Response
+        let response = await fetch(request);
+        // Call the onResponse callback, if provided
+        if (this.onResponse) {
+            const customResponse = await this.onResponse(response);
+            if (customResponse instanceof Response)
+                response = customResponse;
+        }
+        // Validate the Response
+        if (!response.ok || !response.headers.get("Content-Type")?.includes("application/json")) {
+            // Unload the response body to prevent memory leaks
+            const body = await response.text().catch(() => undefined);
+            throw new HttpRequestError(response, body);
+        }
+        // Parse the response body
+        const body = await response.json();
+        // Check if the response is an error
+        if (body?.type === "error") {
+            throw new HttpRequestError(response, body?.message);
+        }
+        // Return the response body
+        return body;
+    }
+}
+/** Merges multiple {@linkcode HeadersInit} into one {@linkcode Headers}. */
+function mergeHeadersInit(...inits) {
+    if (inits.length === 0 || inits.length === 1) {
+        return new Headers(inits[0]);
+    }
+    const merged = new Headers();
+    for (const headers of inits) {
+        const iterator = Symbol.iterator in headers ? headers : Object.entries(headers);
+        for (const [key, value] of iterator) {
+            merged.set(key, value);
+        }
+    }
+    return merged;
+}
+/** Merges multiple {@linkcode RequestInit} into one {@linkcode RequestInit}. */
+function mergeRequestInit(...inits) {
+    const merged = inits.reduce((acc, init) => ({ ...acc, ...init }), {});
+    const headersList = inits.map((init) => init.headers)
+        .filter((headers) => typeof headers === "object");
+    if (headersList.length > 0) {
+        merged.headers = mergeHeadersInit(...headersList);
+    }
+    const signals = inits.map((init) => init.signal)
+        .filter((signal) => signal instanceof AbortSignal);
+    if (signals.length > 0) {
+        merged.signal = signals.length > 1 ? AbortSignal.any(signals) : signals[0];
+    }
+    return merged;
+}
+
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+/**
+ * Resolve a {@linkcode Promise} after a given amount of milliseconds.
+ *
+ * @throws {DOMException} If the optional signal is aborted before the delay
+ * duration, and `signal.reason` is undefined.
+ * @param ms Duration in milliseconds for how long the delay should last.
+ * @param options Additional options.
+ *
+ * @example Basic usage
+ * ```ts no-assert
+ * import { delay } from "@std/async/delay";
+ *
+ * // ...
+ * const delayedPromise = delay(100);
+ * const result = await delayedPromise;
+ * // ...
+ * ```
+ *
+ * @example Disable persistence
+ *
+ * Setting `persistent` to `false` will allow the process to continue to run as
+ * long as the timer exists.
+ *
+ * ```ts no-assert ignore
+ * import { delay } from "@std/async/delay";
+ *
+ * // ...
+ * await delay(100, { persistent: false });
+ * // ...
+ * ```
+ */
+function delay(ms, options = {}) {
+    const { signal, persistent = true } = options;
+    if (signal?.aborted)
+        return Promise.reject(signal.reason);
+    return new Promise((resolve, reject) => {
+        const abort = () => {
+            clearTimeout(i);
+            reject(signal?.reason);
+        };
+        const done = () => {
+            signal?.removeEventListener("abort", abort);
+            resolve();
+        };
+        const i = setTimeout(done, ms);
+        signal?.addEventListener("abort", abort, { once: true });
+        if (persistent === false) {
+            try {
+                // @ts-ignore For browser compatibility
+                Deno.unrefTimer(i);
+            }
+            catch (error) {
+                if (!(error instanceof ReferenceError)) {
+                    throw error;
+                }
+                // deno-lint-ignore no-console
+                console.error("`persistent` option is only available in Deno");
+            }
+        }
+    });
+}
+
+// deno-lint-ignore-file no-explicit-any
+/** Simple FIFO (First In, First Out) buffer implementation. */
+class FIFOMessageBuffer {
+    queue = [];
+    push(data, signal) {
+        this.queue.push({ data, signal });
+    }
+    *[Symbol.iterator]() {
+        while (this.queue.length > 0) {
+            const { data, signal } = this.queue.shift();
+            if (signal?.aborted)
+                continue;
+            yield data;
+        }
+    }
+}
+/** Error thrown when reconnection problems occur. */
+class ReconnectingWebSocketError extends TransportError {
+    code;
+    constructor(code, cause) {
+        super(`Error when reconnecting WebSocket: ${code}`);
+        this.code = code;
+        this.name = "ReconnectingWebSocketError";
+        this.cause = cause;
+    }
+}
+/**
+ * A WebSocket that automatically reconnects when disconnected.
+ * Fully compatible with standard WebSocket API.
+ */
+class ReconnectingWebSocket {
+    _socket;
+    _protocols;
+    _listeners = [];
+    _attempt = 0;
+    reconnectOptions;
+    reconnectAbortController = new AbortController();
+    constructor(url, protocols, options) {
+        this.reconnectOptions = {
+            maxRetries: options?.maxRetries ?? 3,
+            connectionTimeout: options?.connectionTimeout === undefined ? 10_000 : options.connectionTimeout,
+            connectionDelay: options?.connectionDelay ?? ((n) => Math.min(~~(1 << n) * 150, 10_000)),
+            shouldReconnect: options?.shouldReconnect ?? (() => true),
+            messageBuffer: options?.messageBuffer ?? new FIFOMessageBuffer(),
+        };
+        this._socket = this._createSocket(url, protocols);
+        this._protocols = protocols;
+        this._setupEventListeners();
+    }
+    _createSocket(url, protocols) {
+        const socket = new WebSocket(url, protocols);
+        if (this.reconnectOptions.connectionTimeout === null)
+            return socket;
+        const timeoutId = setTimeout(() => {
+            socket.removeEventListener("open", openHandler);
+            socket.removeEventListener("close", closeHandler);
+            socket.close(3008, "Timeout"); // https://www.iana.org/assignments/websocket/websocket.xml#close-code-number
+        }, this.reconnectOptions.connectionTimeout);
+        const openHandler = () => {
+            socket.removeEventListener("close", closeHandler);
+            clearTimeout(timeoutId);
+        };
+        const closeHandler = () => {
+            socket.removeEventListener("open", openHandler);
+            clearTimeout(timeoutId);
+        };
+        socket.addEventListener("open", openHandler, { once: true });
+        socket.addEventListener("close", closeHandler, { once: true });
+        return socket;
+    }
+    /** Initializes the internal event listeners for the socket. */
+    _setupEventListeners() {
+        this._socket.addEventListener("open", this._open, { once: true });
+        this._socket.addEventListener("close", this._close, { once: true });
+    }
+    _open = () => {
+        // Reset the attempt counter
+        this._attempt = 0;
+        // Send all buffered messages
+        for (const message of this.reconnectOptions.messageBuffer) {
+            this._socket.send(message);
+        }
+    };
+    _close = async (event) => {
+        try {
+            // If the event was triggered but the socket is not closing, ignore it
+            if (this._socket.readyState !== ReconnectingWebSocket.CLOSING &&
+                this._socket.readyState !== ReconnectingWebSocket.CLOSED)
+                return;
+            // If the instance is terminated, do not attempt to reconnect
+            if (this.reconnectAbortController.signal.aborted)
+                return;
+            // Check if reconnection should be attempted
+            if (++this._attempt > this.reconnectOptions.maxRetries) {
+                this._cleanup("RECONNECTION_LIMIT_REACHED");
+                return;
+            }
+            const userDecision = await this.reconnectOptions.shouldReconnect(event, this.reconnectAbortController.signal);
+            if (this.reconnectAbortController.signal.aborted)
+                return;
+            if (!userDecision) {
+                this._cleanup("RECONNECTION_STOPPED_BY_USER");
+                return;
+            }
+            // Delay before reconnecting
+            const reconnectDelay = typeof this.reconnectOptions.connectionDelay === "number"
+                ? this.reconnectOptions.connectionDelay
+                : await this.reconnectOptions.connectionDelay(this._attempt, this.reconnectAbortController.signal);
+            if (this.reconnectAbortController.signal.aborted)
+                return;
+            await delay(reconnectDelay, { signal: this.reconnectAbortController.signal });
+            // Create a new WebSocket instance
+            const { onclose, onerror, onmessage, onopen } = this._socket;
+            this._socket = this._createSocket(this._socket.url, this._protocols);
+            // Reconnect all listeners
+            this._setupEventListeners();
+            this._listeners.forEach(({ type, listenerProxy, options }) => {
+                this._socket.addEventListener(type, listenerProxy, options);
+            });
+            this._socket.onclose = onclose;
+            this._socket.onerror = onerror;
+            this._socket.onmessage = onmessage;
+            this._socket.onopen = onopen;
+        }
+        catch (error) {
+            this._cleanup("UNKNOWN_ERROR", error);
+        }
+    };
+    /** Clean up internal resources. */
+    _cleanup(code, cause) {
+        this.reconnectAbortController.abort(new ReconnectingWebSocketError(code, cause));
+        this._listeners = [];
+        this._socket.close();
+    }
+    // WebSocket property implementations
+    get url() {
+        return this._socket.url;
+    }
+    get readyState() {
+        return this._socket.readyState;
+    }
+    get bufferedAmount() {
+        return this._socket.bufferedAmount;
+    }
+    get extensions() {
+        return this._socket.extensions;
+    }
+    get protocol() {
+        return this._socket.protocol;
+    }
+    get binaryType() {
+        return this._socket.binaryType;
+    }
+    set binaryType(value) {
+        this._socket.binaryType = value;
+    }
+    CONNECTING = 0;
+    OPEN = 1;
+    CLOSING = 2;
+    CLOSED = 3;
+    static CONNECTING = 0;
+    static OPEN = 1;
+    static CLOSING = 2;
+    static CLOSED = 3;
+    get onclose() {
+        return this._socket.onclose;
+    }
+    set onclose(value) {
+        this._socket.onclose = value;
+    }
+    get onerror() {
+        return this._socket.onerror;
+    }
+    set onerror(value) {
+        this._socket.onerror = value;
+    }
+    get onmessage() {
+        return this._socket.onmessage;
+    }
+    set onmessage(value) {
+        this._socket.onmessage = value;
+    }
+    get onopen() {
+        return this._socket.onopen;
+    }
+    set onopen(value) {
+        this._socket.onopen = value;
+    }
+    /**
+     * @param permanently - If `true`, the connection will be permanently closed. Default is `true`.
+     */
+    close(code, reason, permanently = true) {
+        this._socket.close(code, reason);
+        if (permanently)
+            this._cleanup("USER_INITIATED_CLOSE");
+    }
+    /**
+     * @param signal - `AbortSignal` to cancel sending a message if it was in the buffer.
+     * @note If the connection is not open, the data will be buffered and sent when the connection is established.
+     */
+    send(data, signal) {
+        if (signal?.aborted)
+            return;
+        if (this._socket.readyState !== ReconnectingWebSocket.OPEN && !this.reconnectAbortController.signal.aborted) {
+            this.reconnectOptions.messageBuffer.push(data, signal);
+        }
+        else {
+            this._socket.send(data);
+        }
+    }
+    addEventListener(type, listener, options) {
+        // Wrap the listener to handle reconnection
+        let listenerProxy;
+        if (this.reconnectAbortController.signal.aborted) {
+            // If the instance is terminated, use the original listener
+            listenerProxy = listener;
+        }
+        else {
+            // Check if the listener is already registered
+            const index = this._listeners.findIndex((e) => listenersMatch(e, { type, listener, options }));
+            if (index !== -1) {
+                // Use the existing listener proxy
+                listenerProxy = this._listeners[index].listenerProxy;
+            }
+            else {
+                // Wrap the original listener to follow the once option when reconnecting
+                listenerProxy = (event) => {
+                    try {
+                        if (typeof listener === "function") {
+                            listener.call(this, event);
+                        }
+                        else {
+                            listener.handleEvent(event);
+                        }
+                    }
+                    finally {
+                        // If the listener is marked as once, remove it after the first invocation
+                        if (typeof options === "object" && options.once === true) {
+                            const index = this._listeners.findIndex((e) => listenersMatch(e, { type, listener, options }));
+                            if (index !== -1) {
+                                this._listeners.splice(index, 1);
+                            }
+                        }
+                    }
+                };
+                this._listeners.push({ type, listener, options, listenerProxy });
+            }
+        }
+        // Add the wrapped (or original) listener
+        this._socket.addEventListener(type, listenerProxy, options);
+    }
+    removeEventListener(type, listener, options) {
+        // Remove a wrapped listener, not an original listener
+        const index = this._listeners.findIndex((e) => listenersMatch(e, { type, listener, options }));
+        if (index !== -1) {
+            const { listenerProxy } = this._listeners[index];
+            this._socket.removeEventListener(type, listenerProxy, options);
+            this._listeners.splice(index, 1);
+        }
+        else {
+            // If the wrapped listener is not found, remove the original listener
+            this._socket.removeEventListener(type, listener, options);
+        }
+    }
+    dispatchEvent(event) {
+        return this._socket.dispatchEvent(event);
+    }
+}
+/** Check if two event listeners are the same (just like EventTarget). */
+function listenersMatch(a, b) {
+    // EventTarget only compares capture in options, even if one is an object and the other is boolean
+    const aCapture = Boolean(typeof a.options === "object" ? a.options.capture : a.options);
+    const bCapture = Boolean(typeof b.options === "object" ? b.options.capture : b.options);
+    return a.type === b.type && a.listener === b.listener && aCapture === bCapture;
+}
+
+class TypedEventTarget extends EventTarget {
+    /**
+     * Dispatches a synthetic event event to target and returns true if either
+     * event's cancelable attribute value is false or its preventDefault() method
+     * was not invoked, and false otherwise.
+     */
+    dispatchTypedEvent(_type, event) {
+        return super.dispatchEvent(event);
+    }
+}
+
+/** Listens for WebSocket messages and sends them as Hyperliquid typed events. */
+class HyperliquidEventTarget extends TypedEventTarget {
+    constructor(socket) {
+        super();
+        socket.addEventListener("message", (event) => {
+            try {
+                const msg = JSON.parse(event.data);
+                if (isHyperliquidMsg(msg)) {
+                    this.dispatchEvent(new CustomEvent(msg.channel, { detail: msg.data }));
+                }
+                else if (isExplorerBlockMsg(msg)) {
+                    this.dispatchEvent(new CustomEvent("_explorerBlock", { detail: msg }));
+                }
+                else if (isExplorerTxsMsg(msg)) {
+                    this.dispatchEvent(new CustomEvent("_explorerTxs", { detail: msg }));
+                }
+            }
+            catch {
+                // Ignore JSON parsing errors
+            }
+        });
+    }
+}
+/** Type guard for Hyperliquid messages. */
+function isHyperliquidMsg(value) {
+    return typeof value === "object" && value !== null &&
+        "channel" in value && typeof value.channel === "string";
+}
+/** Type guard for explorer block messages. */
+function isExplorerBlockMsg(value) {
+    return Array.isArray(value) && value.length > 0 &&
+        (typeof value[0] === "object" && value[0] !== null && !Array.isArray(value[0]) &&
+            "height" in value[0] && typeof value[0].height === "number" &&
+            "blockTime" in value[0] && typeof value[0].blockTime === "number" &&
+            "hash" in value[0] && typeof value[0].hash === "string" &&
+            "proposer" in value[0] && typeof value[0].proposer === "string" &&
+            "numTxs" in value[0] && typeof value[0].numTxs === "number");
+}
+/** Type guard for explorer transactions messages. */
+function isExplorerTxsMsg(value) {
+    return Array.isArray(value) && value.length > 0 &&
+        (typeof value[0] === "object" && value[0] !== null && !Array.isArray(value[0]) &&
+            "action" in value[0] && typeof value[0].action === "object" && value[0].action !== null &&
+            "block" in value[0] && typeof value[0].block === "number" &&
+            "error" in value[0] && (typeof value[0].error === "string" || value[0].error === null) &&
+            "hash" in value[0] && typeof value[0].hash === "string" &&
+            "time" in value[0] && typeof value[0].time === "number" &&
+            "user" in value[0] && typeof value[0].user === "string");
+}
+
+/**
+ * Error thrown when a WebSocket request fails:
+ * - When the WebSocket connection is closed
+ * - When the server responds with an error message
+ */
+class WebSocketRequestError extends TransportError {
+    constructor(message) {
+        super(message);
+        this.name = "WebSocketRequestError";
+    }
+}
+/**
+ * Manages WebSocket requests to the Hyperliquid API.
+ * Handles request creation, sending, and mapping responses to their corresponding requests.
+ */
+class WebSocketAsyncRequest {
+    socket;
+    lastId = 0;
+    queue = [];
+    lastRequestTime = 0;
+    /**
+     * Creates a new WebSocket async request handler.
+     * @param socket - WebSocket connection instance for sending requests to the Hyperliquid WebSocket API
+     * @param hlEvents - Used to recognize Hyperliquid responses and match them with sent requests
+     */
+    constructor(socket, hlEvents) {
+        this.socket = socket;
+        // Monitor responses and match the pending request
+        hlEvents.addEventListener("subscriptionResponse", (event) => {
+            // Use a stringified request as an id
+            const id = WebSocketAsyncRequest.requestToId(event.detail);
+            this.queue.findLast((item) => item.id === id)?.resolve(event.detail);
+        });
+        hlEvents.addEventListener("post", (event) => {
+            const data = event.detail.response.type === "info"
+                ? event.detail.response.payload.data
+                : event.detail.response.payload;
+            this.queue.findLast((item) => item.id === event.detail.id)?.resolve(data);
+        });
+        hlEvents.addEventListener("pong", () => {
+            this.queue.findLast((item) => item.id === "ping")?.resolve();
+        });
+        hlEvents.addEventListener("error", (event) => {
+            try {
+                // Error event doesn't have an id, use original request to match
+                const request = event.detail.match(/{.*}/)?.[0];
+                if (!request)
+                    return;
+                const parsedRequest = JSON.parse(request);
+                // For `post` requests
+                if ("id" in parsedRequest && typeof parsedRequest.id === "number") {
+                    this.queue.findLast((item) => item.id === parsedRequest.id)?.reject(new WebSocketRequestError(`Cannot complete WebSocket request: ${event.detail}`));
+                    return;
+                }
+                // For `subscribe` and `unsubscribe` requests
+                if ("subscription" in parsedRequest &&
+                    typeof parsedRequest.subscription === "object" && parsedRequest.subscription !== null) {
+                    const id = WebSocketAsyncRequest.requestToId(parsedRequest);
+                    this.queue.findLast((item) => item.id === id)?.reject(new WebSocketRequestError(`Cannot complete WebSocket request: ${event.detail}`));
+                    return;
+                }
+                // For already/invalid subscribed requests
+                if (event.detail.startsWith("Already subscribed") || event.detail.startsWith("Invalid subscription")) {
+                    const id = WebSocketAsyncRequest.requestToId({
+                        method: "subscribe",
+                        subscription: parsedRequest,
+                    });
+                    this.queue.findLast((item) => item.id === id)?.reject(new WebSocketRequestError(`Cannot complete WebSocket request: ${event.detail}`));
+                    return;
+                }
+                // For already unsubscribed requests
+                if (event.detail.startsWith("Already unsubscribed")) {
+                    const id = WebSocketAsyncRequest.requestToId({
+                        method: "unsubscribe",
+                        subscription: parsedRequest,
+                    });
+                    this.queue.findLast((item) => item.id === id)?.reject(new WebSocketRequestError(`Cannot complete WebSocket request: ${event.detail}`));
+                    return;
+                }
+                // For unknown requests
+                const id = WebSocketAsyncRequest.requestToId(parsedRequest);
+                this.queue.findLast((item) => item.id === id)?.reject(new WebSocketRequestError(`Cannot complete WebSocket request: ${event.detail}`));
+            }
+            catch {
+                // Ignore JSON parsing errors
+            }
+        });
+        // Throws all pending requests if the connection is dropped
+        socket.addEventListener("close", () => {
+            this.queue.forEach(({ reject }) => {
+                reject(new WebSocketRequestError("Cannot complete WebSocket request: connection is closed"));
+            });
+            this.queue = [];
+        });
+    }
+    async request(method, payload_or_signal, maybeSignal) {
+        const payload = payload_or_signal instanceof AbortSignal ? undefined : payload_or_signal;
+        const signal = payload_or_signal instanceof AbortSignal ? payload_or_signal : maybeSignal;
+        // Reject the request if the signal is aborted
+        if (signal?.aborted)
+            return Promise.reject(signal.reason);
+        // Create a request
+        let id;
+        let request;
+        if (method === "post") {
+            id = ++this.lastId;
+            request = { method, id, request: payload };
+        }
+        else if (method === "ping") {
+            id = "ping";
+            request = { method };
+        }
+        else {
+            request = { method, subscription: payload };
+            id = WebSocketAsyncRequest.requestToId(request);
+        }
+        // Send the request
+        this.socket.send(JSON.stringify(request), signal);
+        this.lastRequestTime = Date.now();
+        // Wait for a response
+        const { promise, resolve, reject } = Promise.withResolvers();
+        this.queue.push({ id, resolve, reject });
+        const onAbort = () => reject(signal?.reason);
+        signal?.addEventListener("abort", onAbort, { once: true });
+        return await promise.finally(() => {
+            const index = this.queue.findLastIndex((item) => item.id === id);
+            if (index !== -1)
+                this.queue.splice(index, 1);
+            signal?.removeEventListener("abort", onAbort);
+        });
+    }
+    /** Normalizes an object and then converts it to a string. */
+    static requestToId(value) {
+        const lowerHex = containsUppercaseHex(value) ? deepLowerHex(value) : value;
+        const sorted = deepSortKeys(lowerHex);
+        return JSON.stringify(sorted); // Also removes undefined
+    }
+}
+/** Deeply converts hexadecimal strings in an object/array to lowercase. */
+function deepLowerHex(obj) {
+    if (typeof obj === "string") {
+        return /^(0X[0-9a-fA-F]*|0x[0-9a-fA-F]*[A-F][0-9a-fA-F]*)$/.test(obj) ? obj.toLowerCase() : obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(deepLowerHex);
+    }
+    if (typeof obj === "object" && obj !== null) {
+        const result = {};
+        const entries = Object.entries(obj);
+        for (const [key, value] of entries) {
+            result[key] = deepLowerHex(value);
+        }
+        return result;
+    }
+    return obj;
+}
+/** Check if an object contains uppercase hexadecimal strings. */
+function containsUppercaseHex(obj) {
+    const str = JSON.stringify(obj);
+    return /0X[0-9a-fA-F]*|0x[0-9a-fA-F]*[A-F][0-9a-fA-F]*/.test(str);
+}
+/** Deeply sort the keys of an object. */
+function deepSortKeys(obj) {
+    if (typeof obj !== "object" || obj === null) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(deepSortKeys);
+    }
+    const result = {};
+    const keys = Object.keys(obj).sort();
+    for (const key of keys) {
+        result[key] = deepSortKeys(obj[key]);
+    }
+    return result;
+}
+
+/** WebSocket implementation of the REST and Subscription transport interfaces. */
+class WebSocketTransport {
+    _wsRequester;
+    _hlEvents;
+    _keepAliveTimeout = null;
+    _subscriptions = new Map();
+    _isReconnecting = false;
+    /**
+     * Request timeout in ms.
+     * Set to `null` to disable.
+     */
+    timeout;
+    /** Keep-alive configuration. */
+    keepAlive;
+    /** Enable automatic resubscription after reconnection. */
+    autoResubscribe;
+    /** The WebSocket that is used for communication. */
+    socket;
+    /**
+     * Creates a new WebSocket transport instance.
+     * @param options - Configuration options for the WebSocket transport layer.
+     */
+    constructor(options) {
+        this.socket = new ReconnectingWebSocket(options?.url ?? "wss://api.hyperliquid.xyz/ws", undefined, options?.reconnect);
+        this._hlEvents = new HyperliquidEventTarget(this.socket);
+        this._wsRequester = new WebSocketAsyncRequest(this.socket, this._hlEvents);
+        this.timeout = options?.timeout === undefined ? 10_000 : options.timeout;
+        this.keepAlive = {
+            interval: options?.keepAlive?.interval === undefined ? 30_000 : options.keepAlive?.interval,
+            timeout: options?.keepAlive?.timeout === undefined ? this.timeout : options.keepAlive?.timeout,
+        };
+        this.autoResubscribe = options?.autoResubscribe ?? true;
+        // Initialize listeners
+        this.socket.addEventListener("open", () => {
+            this._keepAliveStart();
+            this._resubscribeStart();
+        });
+        this.socket.addEventListener("close", () => {
+            this._keepAliveStop();
+            this._resubscribeStop();
+            this._isReconnecting = true;
+        });
+    }
+    /**
+     * Sends a request to the Hyperliquid API via WebSocket.
+     *
+     * Note: Explorer requests are not supported in the Hyperliquid WebSocket API.
+     *
+     * @param endpoint - The API endpoint to send the request to (`explorer` requests are not supported).
+     * @param payload - The payload to send with the request.
+     * @param signal - An optional abort signal.
+     * @returns A promise that resolves with parsed JSON response body.
+     * @throws {WebSocketRequestError} - An error that occurs when a WebSocket request fails.
+     */
+    request(type, payload, signal) {
+        const timeoutSignal = this.timeout ? AbortSignal.timeout(this.timeout) : undefined;
+        const combinedSignal = signal && timeoutSignal
+            ? AbortSignal.any([signal, timeoutSignal])
+            : signal ?? timeoutSignal;
+        return this._wsRequester.request("post", {
+            type: type === "exchange" ? "action" : type,
+            payload,
+        }, combinedSignal);
+    }
+    /**
+     * Subscribes to a Hyperliquid event channel.
+     *
+     * Sends a subscription request to the server and listens for events.
+     *
+     * @param channel - The event channel to listen to.
+     * @param payload - A payload to send with the subscription request.
+     * @param listener - A function to call when the event is dispatched.
+     * @returns A promise that resolves with a {@link Subscription} object to manage the subscription lifecycle.
+     * @throws {WebSocketRequestError} - An error that occurs when a WebSocket request fails.
+     */
+    async subscribe(channel, payload, listener) {
+        // Create a unique identifier for the subscription
+        const id = WebSocketAsyncRequest.requestToId(payload);
+        // Initialize new subscription, if it doesn't exist
+        let subscription = this._subscriptions.get(id);
+        if (!subscription) {
+            // Send subscription request
+            const promise = this._wsRequester.request("subscribe", payload);
+            // Cache subscription info
+            subscription = {
+                listeners: new Map(),
+                promise,
+                resubscribeAbortController: new AbortController(),
+            };
+            this._subscriptions.set(id, subscription);
+        }
+        // Initialize new listener, if it doesn't exist
+        let unsubscribe = subscription.listeners.get(listener);
+        if (!unsubscribe) {
+            // Create new unsubscribe function
+            unsubscribe = async () => {
+                // Remove listener and cleanup
+                this._hlEvents.removeEventListener(channel, listener);
+                const subscription = this._subscriptions.get(id);
+                subscription?.listeners.delete(listener);
+                // If no listeners remain, remove subscription entirely
+                if (subscription?.listeners.size === 0) {
+                    // Cleanup subscription
+                    this._subscriptions.delete(id);
+                    // If the socket is open, send unsubscription request
+                    if (this.socket.readyState === ReconnectingWebSocket.OPEN) {
+                        await this._wsRequester.request("unsubscribe", payload);
+                    }
+                }
+            };
+            // Add listener and cache unsubscribe function
+            this._hlEvents.addEventListener(channel, listener);
+            subscription.listeners.set(listener, unsubscribe);
+        }
+        // Wait for the initial subscription request to complete
+        await subscription.promise;
+        // Return subscription control object
+        return {
+            unsubscribe,
+            resubscribeSignal: subscription.resubscribeAbortController?.signal,
+        };
+    }
+    /**
+     * Waits until the WebSocket connection is ready.
+     * @param signal - An optional abort signal.
+     * @returns A promise that resolves when the connection is ready.
+     */
+    ready(signal) {
+        return new Promise((resolve, reject) => {
+            const combinedSignal = signal
+                ? AbortSignal.any([this.socket.reconnectAbortController.signal, signal])
+                : this.socket.reconnectAbortController.signal;
+            if (combinedSignal.aborted)
+                return reject(combinedSignal.reason);
+            if (this.socket.readyState === ReconnectingWebSocket.OPEN)
+                return resolve();
+            const handleOpen = () => {
+                combinedSignal.removeEventListener("abort", handleAbort);
+                resolve();
+            };
+            const handleAbort = () => {
+                this.socket.removeEventListener("open", handleOpen);
+                reject(combinedSignal.reason);
+            };
+            this.socket.addEventListener("open", handleOpen, { once: true });
+            combinedSignal.addEventListener("abort", handleAbort, { once: true });
+        });
+    }
+    /**
+     * Closes the WebSocket connection and waits until it is fully closed.
+     * @param signal - An optional abort signal.
+     * @returns A promise that resolves when the connection is fully closed.
+     */
+    close(signal) {
+        return new Promise((resolve, reject) => {
+            if (signal?.aborted)
+                return reject(signal.reason);
+            if (this.socket.readyState === ReconnectingWebSocket.CLOSED)
+                return resolve();
+            const handleClose = () => {
+                signal?.removeEventListener("abort", handleAbort);
+                resolve();
+            };
+            const handleAbort = () => {
+                this.socket.removeEventListener("close", handleClose);
+                reject(signal?.reason);
+            };
+            this.socket.addEventListener("close", handleClose, { once: true });
+            signal?.addEventListener("abort", handleAbort, { once: true });
+            this.socket.close();
+        });
+    }
+    /** Keep the connection alive. Sends ping only when necessary. */
+    _keepAliveStart() {
+        if (this.keepAlive.interval === null || this._keepAliveTimeout)
+            return;
+        const tick = async () => {
+            if (this.socket.readyState !== ReconnectingWebSocket.OPEN || !this._keepAliveTimeout ||
+                this.keepAlive.interval === null)
+                return;
+            // Check if the last request was sent more than the keep-alive interval ago
+            if (Date.now() - this._wsRequester.lastRequestTime >= this.keepAlive.interval) {
+                const timeoutSignal = this.keepAlive.timeout ? AbortSignal.timeout(this.keepAlive.timeout) : undefined;
+                await this._wsRequester.request("ping", timeoutSignal)
+                    .catch(() => undefined); // Ignore errors
+            }
+            // Schedule the next ping
+            if (this.socket.readyState === ReconnectingWebSocket.OPEN && this._keepAliveTimeout &&
+                this.keepAlive.interval !== null) {
+                const nextDelay = this.keepAlive.interval - (Date.now() - this._wsRequester.lastRequestTime);
+                this._keepAliveTimeout = setTimeout(tick, nextDelay);
+            }
+        };
+        this._keepAliveTimeout = setTimeout(tick, this.keepAlive.interval);
+    }
+    _keepAliveStop() {
+        if (this._keepAliveTimeout !== null) {
+            clearTimeout(this._keepAliveTimeout);
+            this._keepAliveTimeout = null;
+        }
+    }
+    /** Resubscribe to all existing subscriptions if auto-resubscribe is enabled. */
+    _resubscribeStart() {
+        if (this.autoResubscribe && this._isReconnecting) {
+            for (const [id, subscriptionInfo] of this._subscriptions.entries()) {
+                subscriptionInfo.promise = this._wsRequester.request("subscribe", JSON.parse(id))
+                    .catch((error) => {
+                    subscriptionInfo.resubscribeAbortController?.abort(error);
+                });
+            }
+        }
+    }
+    _resubscribeStop() {
+        if (!this.autoResubscribe || this.socket.reconnectAbortController.signal.aborted) {
+            for (const subscriptionInfo of this._subscriptions.values()) {
+                for (const [_, unsubscribe] of subscriptionInfo.listeners) {
+                    unsubscribe(); // does not cause an error if used when the connection is closed
+                }
+            }
+        }
+    }
+    async [Symbol.asyncDispose]() {
+        await this.close();
+    }
+}
+
+/**
+ * Hyperliquid service client for direct API communication
+ */
+class HyperliquidService {
+    constructor(wsUrl = 'wss://api.hyperliquid.xyz/ws', isTestnet = false) {
+        // Market data
+        this.allMidsData = null;
+        this.webData2 = null;
+        // Optimized caches
+        this.assetBySymbol = new Map();
+        this.allAssetsCache = null;
+        // Initialize HTTP client
+        this.infoClient = new InfoClient({
+            transport: new HttpTransport(),
+        });
+        // Initialize WebSocket if URL provided
+        if (wsUrl) {
+            this.initializeWebSocket(wsUrl);
+        }
+    }
+    initializeWebSocket(wsUrl) {
+        this.wsTransport = new WebSocketTransport({
+            url: wsUrl,
+        });
+        this.subsClient = new SubscriptionClient({ transport: this.wsTransport });
+        // Subscribe to all mids for real-time price data
+        this.subsClient.allMids((data) => {
+            this.allMidsData = data;
+        });
+        // Subscribe to web data for asset information
+        // Will be updated when address is set via updateUserAddress method
+    }
+    /**
+     * Refresh asset cache when webData2 updates
+     */
+    refreshAssetCache() {
+        var _a, _b;
+        if (!((_a = this.webData2) === null || _a === void 0 ? void 0 : _a.meta.universe) || !((_b = this.webData2) === null || _b === void 0 ? void 0 : _b.assetCtxs))
+            return;
+        this.assetBySymbol.clear();
+        this.allAssetsCache = null;
+        // Build optimized lookup map
+        this.webData2.meta.universe.forEach((universe, index) => {
+            const assetCtx = this.webData2.assetCtxs[index];
+            if (assetCtx) {
+                this.assetBySymbol.set(universe.name, {
+                    universe,
+                    assetCtx,
+                    index
+                });
+            }
+        });
+    }
+    /**
+     * Get asset information by symbol - O(1) lookup
+     */
+    getAssetInfo(symbol) {
+        var _a;
+        return ((_a = this.assetBySymbol.get(symbol)) === null || _a === void 0 ? void 0 : _a.universe) || null;
+    }
+    /**
+     * Get asset context by symbol - O(1) lookup
+     */
+    getAssetCtx(symbol) {
+        var _a;
+        return ((_a = this.assetBySymbol.get(symbol)) === null || _a === void 0 ? void 0 : _a.assetCtx) || null;
+    }
+    /**
+     * Get asset index by symbol - O(1) lookup
+     */
+    getAssetIndex(symbol) {
+        const data = this.assetBySymbol.get(symbol);
+        return data ? data.index : null;
+    }
+    /**
+     * Get all assets with caching
+     */
+    getAllAssets() {
+        if (this.allAssetsCache) {
+            return this.allAssetsCache;
+        }
+        this.allAssetsCache = Array.from(this.assetBySymbol.values()).map(data => ({
+            universe: data.universe,
+            assetsCtx: data.assetCtx,
+        }));
+        return this.allAssetsCache;
+    }
+    /**
+     * Get current market price for an asset
+     */
+    getMarketPrice(symbol) {
+        var _a;
+        return parseFloat(((_a = this.allMidsData) === null || _a === void 0 ? void 0 : _a.mids[symbol]) || '0');
+    }
+    /**
+     * Get optimal decimal places for an asset
+     */
+    getOptimalDecimal(symbol) {
+        const asset = this.getAssetInfo(symbol);
+        return asset ? asset.szDecimals : 8;
+    }
+    /**
+     * Get user's open positions from Hyperliquid
+     */
+    async getUserPositions(address) {
+        try {
+            const state = await this.infoClient.clearinghouseState({
+                user: address
+            });
+            return state.assetPositions || [];
+        }
+        catch (error) {
+            console.error('Failed to get user positions:', error);
+            return [];
+        }
+    }
+    /**
+     * Get user's account summary from Hyperliquid
+     */
+    async getAccountSummary(address) {
+        try {
+            return await this.infoClient.clearinghouseState({
+                user: address
+            });
+        }
+        catch (error) {
+            console.error('Failed to get account summary:', error);
+            return null;
+        }
+    }
+    /**
+     * Get user's open orders from Hyperliquid
+     */
+    async getUserOrders(address) {
+        try {
+            return await this.infoClient.openOrders({
+                user: address
+            });
+        }
+        catch (error) {
+            console.error('Failed to get user orders:', error);
+            return [];
+        }
+    }
+    /**
+     * Update the user address for webData2 subscription
+     */
+    updateUserAddress(address) {
+        if (this.subsClient && address) {
+            // Subscribe to webData2 with the new address
+            this.subsClient.webData2({
+                user: address,
+            }, (data) => {
+                this.webData2 = data;
+                this.refreshAssetCache();
+            });
+        }
+    }
+    /**
+     * Get the info client instance
+     */
+    getInfoClient() {
+        return this.infoClient;
+    }
+    /**
+     * Check if WebSocket is connected
+     */
+    isWebSocketConnected() {
+        return !!this.subsClient && !!this.wsTransport;
+    }
+    /**
+     * Clean up resources
+     */
+    async cleanup() {
+        if (this.wsTransport && this.wsTransport.close) {
+            await this.wsTransport.close();
+        }
+        this.assetBySymbol.clear();
+        this.allAssetsCache = null;
+        this.allMidsData = null;
+        this.webData2 = null;
+    }
+}
+
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
 function getDefaultExportFromCjs (x) {
@@ -2633,9 +5517,11 @@ const PearHyperliquidContext = createContext(undefined);
 /**
  * React Provider for PearHyperliquidClient
  */
-const PearHyperliquidProvider = ({ config, wsUrl = 'wss://hl-v2.pearprotocol.io/ws', children, }) => {
+const PearHyperliquidProvider = ({ config, wsUrl = 'wss://hl-v2.pearprotocol.io/ws', hyperliquidWsUrl = 'wss://api.hyperliquid.xyz/ws', children, }) => {
     const client = useMemo(() => new PearHyperliquidClient(config), [config]);
     const migrationSDK = useMemo(() => new PearMigrationSDK(client), [client]);
+    // Initialize Hyperliquid service
+    const hyperliquidService = useMemo(() => new HyperliquidService(hyperliquidWsUrl), [hyperliquidWsUrl]);
     // Address state
     const [address, setAddress] = useState(null);
     // WebSocket data state
@@ -2732,10 +5618,16 @@ const PearHyperliquidProvider = ({ config, wsUrl = 'wss://hl-v2.pearprotocol.io/
             });
         }
     }, [isConnected, address, sendMessage]);
+    // Handle address changes for Hyperliquid service
+    useEffect(() => {
+        hyperliquidService.updateUserAddress(address);
+    }, [address, hyperliquidService]);
     const contextValue = useMemo(() => ({
         // Existing clients
         client,
         migrationSDK,
+        // Enhanced services
+        hyperliquidService,
         // Address management
         address,
         setAddress,
@@ -2745,7 +5637,7 @@ const PearHyperliquidProvider = ({ config, wsUrl = 'wss://hl-v2.pearprotocol.io/
         // WebSocket data
         data,
         lastError,
-    }), [client, migrationSDK, address, readyState, isConnected, data, lastError]);
+    }), [client, migrationSDK, hyperliquidService, address, readyState, isConnected, data, lastError]);
     return (jsxRuntimeExports.jsx(PearHyperliquidContext.Provider, { value: contextValue, children: children }));
 };
 /**
@@ -2768,6 +5660,16 @@ const useMigrationSDK = () => {
     }
     return context.migrationSDK;
 };
+/**
+ * Hook to use Hyperliquid service from context
+ */
+const useHyperliquidService = () => {
+    const context = useContext(PearHyperliquidContext);
+    if (!context) {
+        throw new Error('useHyperliquidService must be used within a PearHyperliquidProvider');
+    }
+    return context.hyperliquidService;
+};
 
 /**
  * Hook to manage address (login/logout functionality)
@@ -2796,14 +5698,74 @@ const useTradeHistories = () => {
     return context.data.tradeHistories;
 };
 /**
- * Hook to access open positions
+ * Hook to access open positions with enhanced real-time synchronization
  */
 const useOpenPositions = () => {
     const context = useContext(PearHyperliquidContext);
+    const hyperliquidService = useHyperliquidService();
+    const [enhancedPositions, setEnhancedPositions] = useState([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [lastSyncTime, setLastSyncTime] = useState(null);
     if (!context) {
         throw new Error('useOpenPositions must be used within a PearHyperliquidProvider');
     }
-    return context.data.openPositions;
+    // Get base positions from WebSocket
+    const wsPositions = context.data.openPositions;
+    // Enhance positions with real-time Hyperliquid data
+    const syncPositions = useCallback(async () => {
+        if (!wsPositions || wsPositions.length === 0) {
+            setEnhancedPositions([]);
+            return;
+        }
+        setIsLoading(true);
+        try {
+            // Enhanced positions with real-time market prices from Hyperliquid
+            const enhancedPositionsData = wsPositions.map(wsPos => {
+                // Calculate updated position values using current market prices
+                const enhancedLongAssets = wsPos.longAssets.map(asset => ({
+                    ...asset,
+                    positionValue: asset.platformSize * hyperliquidService.getMarketPrice(asset.coin),
+                }));
+                const enhancedShortAssets = wsPos.shortAssets.map(asset => ({
+                    ...asset,
+                    positionValue: asset.platformSize * hyperliquidService.getMarketPrice(asset.coin),
+                }));
+                // Calculate updated position value and mark ratio
+                const totalPositionValue = enhancedLongAssets.reduce((sum, asset) => sum + asset.positionValue, 0) +
+                    enhancedShortAssets.reduce((sum, asset) => sum + asset.positionValue, 0);
+                return {
+                    ...wsPos,
+                    longAssets: enhancedLongAssets,
+                    shortAssets: enhancedShortAssets,
+                    positionValue: totalPositionValue,
+                    // Add timestamp for when we enhanced with Hyperliquid data
+                    lastSyncAt: new Date().toISOString(),
+                };
+            });
+            setEnhancedPositions(enhancedPositionsData);
+            setLastSyncTime(new Date());
+        }
+        catch (error) {
+            console.error('Failed to enhance positions with Hyperliquid data:', error);
+            // Fall back to WebSocket data if enhancement fails
+            setEnhancedPositions(wsPositions || []);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [wsPositions, hyperliquidService]);
+    // Sync positions whenever WebSocket data changes
+    useEffect(() => {
+        syncPositions();
+    }, [syncPositions]);
+    // Real-time updates are handled automatically through webData2 subscription
+    return {
+        positions: enhancedPositions, // Returns OpenPositionDto[] - fully backward compatible
+        isLoading,
+        lastSyncTime,
+        rawWsPositions: wsPositions, // Expose raw WebSocket data for debugging
+        resync: syncPositions // Manual resync function
+    };
 };
 /**
  * Hook to access open orders
@@ -2816,15 +5778,85 @@ const useOpenOrders = () => {
     return context.data.openOrders;
 };
 /**
- * Hook to access account summary
+ * Hook to access account summary with enhanced real-time data from Hyperliquid
  */
 const useAccountSummary = () => {
     const context = useContext(PearHyperliquidContext);
+    const hyperliquidService = useHyperliquidService();
+    const [enhancedSummary, setEnhancedSummary] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [lastSyncTime, setLastSyncTime] = useState(null);
     if (!context) {
         throw new Error('useAccountSummary must be used within a PearHyperliquidProvider');
     }
-    return context.data.accountSummary;
+    // Get base summary from WebSocket (your backend data)
+    const wsSummary = context.data.accountSummary;
+    // Enhance account summary with fresh Hyperliquid data
+    const syncAccountSummary = useCallback(async () => {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        if (!context.address || !wsSummary) {
+            setEnhancedSummary(wsSummary);
+            return;
+        }
+        setIsLoading(true);
+        try {
+            // Get fresh data from Hyperliquid (like your backend does)
+            const hlAccountSummary = await hyperliquidService.getAccountSummary(context.address);
+            if (hlAccountSummary) {
+                // Enhance your backend data with fresh Hyperliquid data
+                const enhancedSummaryData = {
+                    balanceSummary: {
+                        // Use fresh Hyperliquid data for real-time accuracy
+                        crossMaintenanceMarginUsed: hlAccountSummary.crossMaintenanceMarginUsed || wsSummary.balanceSummary.crossMaintenanceMarginUsed,
+                        crossMarginSummary: {
+                            accountValue: ((_a = hlAccountSummary.crossMarginSummary) === null || _a === void 0 ? void 0 : _a.accountValue) || wsSummary.balanceSummary.crossMarginSummary.accountValue,
+                            totalMarginUsed: ((_b = hlAccountSummary.crossMarginSummary) === null || _b === void 0 ? void 0 : _b.totalMarginUsed) || wsSummary.balanceSummary.crossMarginSummary.totalMarginUsed,
+                            totalNtlPos: ((_c = hlAccountSummary.crossMarginSummary) === null || _c === void 0 ? void 0 : _c.totalNtlPos) || wsSummary.balanceSummary.crossMarginSummary.totalNtlPos,
+                            totalRawUsd: ((_d = hlAccountSummary.crossMarginSummary) === null || _d === void 0 ? void 0 : _d.totalRawUsd) || wsSummary.balanceSummary.crossMarginSummary.totalRawUsd
+                        },
+                        marginSummary: {
+                            accountValue: ((_e = hlAccountSummary.marginSummary) === null || _e === void 0 ? void 0 : _e.accountValue) || wsSummary.balanceSummary.marginSummary.accountValue,
+                            totalMarginUsed: ((_f = hlAccountSummary.marginSummary) === null || _f === void 0 ? void 0 : _f.totalMarginUsed) || wsSummary.balanceSummary.marginSummary.totalMarginUsed,
+                            totalNtlPos: ((_g = hlAccountSummary.marginSummary) === null || _g === void 0 ? void 0 : _g.totalNtlPos) || wsSummary.balanceSummary.marginSummary.totalNtlPos,
+                            totalRawUsd: ((_h = hlAccountSummary.marginSummary) === null || _h === void 0 ? void 0 : _h.totalRawUsd) || wsSummary.balanceSummary.marginSummary.totalRawUsd
+                        },
+                        time: Date.now(), // Current timestamp
+                        // Keep your backend's calculated withdrawable (includes order deductions)
+                        withdrawable: wsSummary.balanceSummary.withdrawable
+                    },
+                    // Keep your backend's agent wallet data
+                    agentWallet: wsSummary.agentWallet
+                };
+                setEnhancedSummary(enhancedSummaryData);
+            }
+            else {
+                // Fallback to WebSocket data if Hyperliquid fails
+                setEnhancedSummary(wsSummary);
+            }
+            setLastSyncTime(new Date());
+        }
+        catch (error) {
+            console.error('Failed to enhance account summary with Hyperliquid:', error);
+            // Fall back to WebSocket data if enhancement fails
+            setEnhancedSummary(wsSummary);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [context.address, wsSummary, hyperliquidService]);
+    // Sync account summary whenever WebSocket data changes
+    useEffect(() => {
+        syncAccountSummary();
+    }, [syncAccountSummary]);
+    // Real-time updates are handled automatically through webData2 subscription
+    return {
+        summary: enhancedSummary, // Returns AccountSummaryResponseDto - fully backward compatible
+        isLoading,
+        lastSyncTime,
+        rawWsSummary: wsSummary, // Expose raw WebSocket data for debugging
+        resync: syncAccountSummary // Manual resync function
+    };
 };
 
-export { PearHyperliquidClient, PearHyperliquidProvider, PearMigrationSDK, PearHyperliquidClient as default, useAccountSummary, useAddress, useMigrationSDK, useOpenOrders, useOpenPositions, usePearHyperliquidClient, useTradeHistories };
+export { HyperliquidService, PearHyperliquidClient, PearHyperliquidProvider, PearMigrationSDK, PearHyperliquidClient as default, useAccountSummary, useAddress, useHyperliquidService, useMigrationSDK, useOpenOrders, useOpenPositions, usePearHyperliquidClient, useTradeHistories };
 //# sourceMappingURL=index.esm.js.map