@pear-protocol/hyperliquid-sdk 0.0.5 → 0.0.7

package/dist/index.esm.js

@@ -1,5 +1,5 @@
 import axios from 'axios';
-import require$$0, { createContext, useMemo, useState, useEffect, useContext, useCallback } from 'react';
+import require$$0, { useState, useEffect, useRef, createContext, useMemo, useContext } from 'react';
 import require$$1 from 'react-dom';
 
 /**
@@ -203,2890 +203,6 @@ 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) {
@@ -5513,17 +2629,7 @@ useEventSource$1.useEventSource = useEventSource;
 
 var useWebSocket = /*@__PURE__*/getDefaultExportFromCjs(dist);
 
-const PearHyperliquidContext = createContext(undefined);
-/**
- * React Provider for PearHyperliquidClient
- */
-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);
+const useHyperliquidWebSocket = ({ wsUrl, address }) => {
     // WebSocket data state
     const [data, setData] = useState({
         tradeHistories: null,
@@ -5618,26 +2724,192 @@ const PearHyperliquidProvider = ({ config, wsUrl = 'wss://hl-v2.pearprotocol.io/
             });
         }
     }, [isConnected, address, sendMessage]);
-    // Handle address changes for Hyperliquid service
+    return {
+        data,
+        connectionStatus: readyState,
+        isConnected,
+        lastError,
+    };
+};
+
+const useHyperliquidNativeWebSocket = ({ address }) => {
+    const [webData2, setWebData2] = useState(null);
+    const [allMids, setAllMids] = useState(null);
+    const [lastError, setLastError] = useState(null);
+    const [subscribedAddress, setSubscribedAddress] = useState(null);
+    const pingIntervalRef = useRef(null);
+    // WebSocket connection to HyperLiquid native API
+    const { lastMessage, readyState, sendJsonMessage } = useWebSocket('wss://api.hyperliquid.xyz/ws', {
+        shouldReconnect: () => true,
+        reconnectAttempts: 5,
+        reconnectInterval: 3000,
+        onOpen: () => console.log('[HyperLiquid WS] Connected to wss://api.hyperliquid.xyz/ws'),
+        onClose: () => console.log('[HyperLiquid WS] Connection closed'),
+        onError: (event) => console.error('[HyperLiquid WS] Connection error:', event),
+        onReconnectStop: () => console.error('[HyperLiquid WS] Reconnection stopped after 5 attempts'),
+    });
+    const isConnected = readyState === dist.ReadyState.OPEN;
+    // Setup ping mechanism
+    useEffect(() => {
+        if (isConnected) {
+            console.log('[HyperLiquid WS] Setting up ping mechanism (30s interval)');
+            // Send ping every 30 seconds
+            pingIntervalRef.current = setInterval(() => {
+                console.log('[HyperLiquid WS] Sending ping');
+                sendJsonMessage({ method: 'ping' });
+            }, 30000);
+        }
+        else {
+            if (pingIntervalRef.current) {
+                console.log('[HyperLiquid WS] Clearing ping interval');
+                clearInterval(pingIntervalRef.current);
+                pingIntervalRef.current = null;
+            }
+        }
+        return () => {
+            if (pingIntervalRef.current) {
+                clearInterval(pingIntervalRef.current);
+                pingIntervalRef.current = null;
+            }
+        };
+    }, [isConnected, sendJsonMessage]);
+    // Handle address subscription changes
+    useEffect(() => {
+        if (!isConnected)
+            return;
+        const DEFAULT_ADDRESS = '0x0000000000000000000000000000000000000000';
+        const userAddress = address || DEFAULT_ADDRESS;
+        if (subscribedAddress === userAddress)
+            return;
+        // Unsubscribe from previous address if exists
+        if (subscribedAddress) {
+            console.log(`[HyperLiquid WS] Unsubscribing from webData2 for previous address: ${subscribedAddress}`);
+            const unsubscribeMessage = {
+                method: 'unsubscribe',
+                subscription: {
+                    type: 'webData2',
+                    user: subscribedAddress,
+                },
+            };
+            sendJsonMessage(unsubscribeMessage);
+        }
+        // Subscribe to webData2 with new address
+        console.log(`[HyperLiquid WS] Subscribing to webData2 for address: ${userAddress}`);
+        const subscribeWebData2 = {
+            method: 'subscribe',
+            subscription: {
+                type: 'webData2',
+                user: userAddress,
+            },
+        };
+        // Subscribe to allMids
+        console.log('[HyperLiquid WS] Subscribing to allMids');
+        const subscribeAllMids = {
+            method: 'subscribe',
+            subscription: {
+                type: 'allMids',
+            },
+        };
+        sendJsonMessage(subscribeWebData2);
+        sendJsonMessage(subscribeAllMids);
+        setSubscribedAddress(userAddress);
+        // Clear previous data when address changes
+        if (subscribedAddress && subscribedAddress !== userAddress) {
+            console.log('[HyperLiquid WS] Address changed, clearing previous webData2');
+            setWebData2(null);
+        }
+    }, [isConnected, address, subscribedAddress, sendJsonMessage]);
+    // Handle incoming WebSocket messages
     useEffect(() => {
-        hyperliquidService.updateUserAddress(address);
-    }, [address, hyperliquidService]);
+        if (!lastMessage)
+            return;
+        try {
+            const message = JSON.parse(lastMessage.data);
+            console.log('[HyperLiquid WS] Received message:', message);
+            // Handle subscription responses
+            if ('success' in message || 'error' in message) {
+                if (message.error) {
+                    console.error('[HyperLiquid WS] Subscription error:', message.error);
+                    setLastError(message.error);
+                }
+                else {
+                    console.log('[HyperLiquid WS] Subscription success:', message);
+                    setLastError(null);
+                }
+                return;
+            }
+            // Handle channel data messages
+            if ('channel' in message && 'data' in message) {
+                const response = message;
+                console.log(`[HyperLiquid WS] Received ${response.channel} data`);
+                switch (response.channel) {
+                    case 'webData2':
+                        console.log('[HyperLiquid WS] Setting webData2:', response.data);
+                        setWebData2(response.data);
+                        break;
+                    case 'allMids':
+                        console.log('[HyperLiquid WS] Setting allMids:', response.data);
+                        setAllMids(response.data);
+                        break;
+                    default:
+                        console.warn(`[HyperLiquid WS] Unknown channel: ${response.channel}`);
+                }
+            }
+        }
+        catch (error) {
+            const errorMessage = `Failed to parse message: ${error instanceof Error ? error.message : String(error)}`;
+            console.error('[HyperLiquid WS] Parse error:', errorMessage, 'Raw message:', lastMessage.data);
+            setLastError(errorMessage);
+        }
+    }, [lastMessage]);
+    return {
+        webData2,
+        allMids,
+        connectionStatus: readyState,
+        isConnected,
+        lastError,
+    };
+};
+
+const PearHyperliquidContext = createContext(undefined);
+/**
+ * React Provider for PearHyperliquidClient
+ */
+const PearHyperliquidProvider = ({ config, wsUrl = 'wss://hl-v2.pearprotocol.io/ws', children, }) => {
+    const client = useMemo(() => new PearHyperliquidClient(config), [config]);
+    const migrationSDK = useMemo(() => new PearMigrationSDK(client), [client]);
+    // Address state
+    const [address, setAddress] = useState(null);
+    // WebSocket connection and data (Pear API)
+    const { data, connectionStatus, isConnected, lastError } = useHyperliquidWebSocket({
+        wsUrl,
+        address,
+    });
+    // HyperLiquid native WebSocket connection
+    const { webData2, allMids, connectionStatus: nativeConnectionStatus, isConnected: nativeIsConnected, lastError: nativeLastError } = useHyperliquidNativeWebSocket({
+        address,
+    });
     const contextValue = useMemo(() => ({
         // Existing clients
         client,
         migrationSDK,
-        // Enhanced services
-        hyperliquidService,
         // Address management
         address,
         setAddress,
-        // WebSocket state
-        connectionStatus: readyState,
+        // WebSocket state (Pear API)
+        connectionStatus,
         isConnected,
-        // WebSocket data
+        // WebSocket data (Pear API)
         data,
         lastError,
-    }), [client, migrationSDK, hyperliquidService, address, readyState, isConnected, data, lastError]);
+        // HyperLiquid native WebSocket state
+        nativeConnectionStatus,
+        nativeIsConnected,
+        nativeLastError,
+        // HyperLiquid native WebSocket data
+        webData2,
+        allMids,
+    }), [client, migrationSDK, address, connectionStatus, isConnected, data, lastError, nativeConnectionStatus, nativeIsConnected, nativeLastError, webData2, allMids]);
     return (jsxRuntimeExports.jsx(PearHyperliquidContext.Provider, { value: contextValue, children: children }));
 };
 /**
@@ -5660,16 +2932,6 @@ 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)
@@ -5687,6 +2949,483 @@ const useAddress = () => {
     };
 };
 
+/**
+ * Position side enum for calculations
+ */
+var PositionSide;
+(function (PositionSide) {
+    PositionSide["LONG"] = "LONG";
+    PositionSide["SHORT"] = "SHORT";
+})(PositionSide || (PositionSide = {}));
+/**
+ * Position calculation utility class
+ */
+class PositionCalculator {
+    constructor(webData2, allMids) {
+        this.webData2 = webData2;
+        this.allMids = allMids;
+    }
+    /**
+     * Get market price for a coin from allMids data
+     */
+    getMarketPrice(coin) {
+        var _a;
+        if (!((_a = this.allMids) === null || _a === void 0 ? void 0 : _a.mids))
+            return 0;
+        // Try exact match first
+        const exactPrice = this.allMids.mids[coin];
+        if (exactPrice) {
+            return Number(exactPrice);
+        }
+        // If coin has a slash (like "BTC/USD"), try just the base currency
+        const baseCurrency = coin.split('/')[0];
+        const basePrice = this.allMids.mids[baseCurrency];
+        if (basePrice) {
+            return Number(basePrice);
+        }
+        console.warn(`[PositionCalculator] No market price found for coin: ${coin}`);
+        return 0;
+    }
+    /**
+     * Get user positions from webData2
+     */
+    getUserPositions() {
+        var _a, _b;
+        return ((_b = (_a = this.webData2) === null || _a === void 0 ? void 0 : _a.clearinghouseState) === null || _b === void 0 ? void 0 : _b.assetPositions) || [];
+    }
+    /**
+     * Calculate updated open positions by syncing platform positions with HyperLiquid data
+     */
+    calculateOpenPositions(platformPositions) {
+        if (!(platformPositions === null || platformPositions === void 0 ? void 0 : platformPositions.length)) {
+            return [];
+        }
+        const hyperliquidPositions = this.getUserPositions();
+        return platformPositions.map(position => this.syncPositionWithHyperliquid(position, hyperliquidPositions));
+    }
+    /**
+     * Sync a single position with HyperLiquid data
+     */
+    syncPositionWithHyperliquid(position, hyperliquidPositions) {
+        // Create a map of HyperLiquid positions by coin for quick lookup
+        const hlPositionsMap = new Map();
+        hyperliquidPositions.forEach(assetPos => {
+            var _a;
+            if ((_a = assetPos.position) === null || _a === void 0 ? void 0 : _a.coin) {
+                hlPositionsMap.set(assetPos.position.coin, assetPos);
+            }
+        });
+        // Combine all assets for processing
+        const allAssets = [
+            ...position.longAssets.map(asset => ({ ...asset, side: PositionSide.LONG })),
+            ...position.shortAssets.map(asset => ({ ...asset, side: PositionSide.SHORT }))
+        ];
+        // Group assets by base currency for multi-pair position handling
+        const assetsByBaseCurrency = this.groupAssetsByBaseCurrency(allAssets);
+        // Sync each asset group with HyperLiquid data
+        const syncResults = [];
+        for (const [baseCurrency, assets] of assetsByBaseCurrency.entries()) {
+            const hlPosition = hlPositionsMap.get(baseCurrency);
+            const groupSyncResults = this.syncAssetGroupWithHyperliquid(assets, hlPosition);
+            syncResults.push(...groupSyncResults);
+        }
+        // Update position sync status based on asset sync results
+        const syncStatus = this.determineSyncStatus(syncResults);
+        // Rebuild position with synced data
+        return this.buildUpdatedPosition(position, syncResults, syncStatus);
+    }
+    /**
+     * Group assets by their base currency
+     */
+    groupAssetsByBaseCurrency(assets) {
+        const grouped = new Map();
+        for (const asset of assets) {
+            const baseCurrency = asset.coin.split('/')[0] || asset.coin;
+            if (!grouped.has(baseCurrency)) {
+                grouped.set(baseCurrency, []);
+            }
+            grouped.get(baseCurrency).push(asset);
+        }
+        return grouped;
+    }
+    /**
+     * Sync a group of assets (same base currency) with HyperLiquid position data
+     */
+    syncAssetGroupWithHyperliquid(assets, hlPosition) {
+        const results = [];
+        // Calculate total platform size for this base currency
+        const totalPlatformSize = assets.reduce((sum, asset) => sum + asset.platformSize, 0);
+        const actualTotalSize = hlPosition ? Math.abs(Number(hlPosition.position.szi || 0)) : 0;
+        // Check if the total size matches (within tolerance)
+        const sizeDifference = Math.abs(actualTotalSize - totalPlatformSize);
+        const sizeDifferencePercentage = totalPlatformSize > 0
+            ? (sizeDifference / totalPlatformSize) * 100
+            : (actualTotalSize > 0 ? 100 : 0);
+        const isGroupExternallyModified = sizeDifferencePercentage > 0.1; // 0.1% tolerance
+        for (const asset of assets) {
+            const platformSize = asset.platformSize;
+            let actualSize = platformSize;
+            let isExternallyModified = isGroupExternallyModified;
+            let cumFunding = {
+                allTime: 0,
+                sinceChange: 0,
+                sinceOpen: 0
+            };
+            let unrealizedPnl = 0;
+            let liquidationPrice = 0;
+            if (hlPosition) {
+                // Proportionally distribute the actual size based on asset's contribution
+                const sizeRatio = totalPlatformSize > 0 ? platformSize / totalPlatformSize : 0;
+                actualSize = actualTotalSize * sizeRatio;
+                // Proportionally distribute funding and PnL based on asset's contribution
+                if (hlPosition.cumFunding) {
+                    cumFunding = {
+                        allTime: Number(hlPosition.cumFunding.allTime || 0),
+                        sinceChange: Number(hlPosition.cumFunding.sinceChange || 0) * sizeRatio,
+                        sinceOpen: Number(hlPosition.cumFunding.sinceOpen || 0) * sizeRatio
+                    };
+                }
+                unrealizedPnl = Number(hlPosition.position.unrealizedPnl || 0) * sizeRatio;
+                liquidationPrice = Number(hlPosition.position.liquidationPx || 0);
+            }
+            else {
+                // Position doesn't exist on HyperLiquid - it was closed externally
+                actualSize = 0;
+                isExternallyModified = true;
+            }
+            results.push({
+                asset,
+                actualSize,
+                isExternallyModified,
+                cumFunding,
+                unrealizedPnl,
+                liquidationPrice,
+                side: asset.side
+            });
+        }
+        return results;
+    }
+    /**
+     * Determine sync status based on asset sync results
+     */
+    determineSyncStatus(syncResults) {
+        const hasExternalModifications = syncResults.some(result => result.isExternallyModified);
+        const allAssetsClosed = syncResults.every(result => result.actualSize === 0);
+        const someAssetsClosed = syncResults.some(result => result.actualSize === 0) && !allAssetsClosed;
+        if (allAssetsClosed) {
+            return 'EXTERNALLY_CLOSED';
+        }
+        else if (someAssetsClosed) {
+            return 'PAIR_BROKEN';
+        }
+        else if (hasExternalModifications) {
+            return 'EXTERNALLY_MODIFIED';
+        }
+        return 'SYNCED';
+    }
+    /**
+     * Build updated position with synced data
+     */
+    buildUpdatedPosition(originalPosition, syncResults, syncStatus) {
+        const longSyncResults = syncResults.filter(result => result.side === PositionSide.LONG);
+        const shortSyncResults = syncResults.filter(result => result.side === PositionSide.SHORT);
+        // Calculate position metrics
+        const currentTotalPositionValue = this.calculateCurrentTotalPositionValue(syncResults);
+        const entryTotalPositionValue = this.calculateEntryTotalPositionValue(syncResults);
+        const totalMarginUsed = entryTotalPositionValue / originalPosition.leverage;
+        return {
+            ...originalPosition,
+            syncStatus,
+            entryRatio: this.calculateEntryRatio(syncResults),
+            markRatio: this.calculateMarkRatio(syncResults),
+            netFunding: this.calculateNetFundingFromSyncResults(syncResults),
+            positionValue: currentTotalPositionValue,
+            marginUsed: totalMarginUsed,
+            unrealizedPnl: this.calculateTotalUnrealizedPnlFromSyncResults(syncResults),
+            lastSyncAt: new Date().toISOString(),
+            longAssets: longSyncResults.map(result => this.mapSyncResultToAssetDto(result)),
+            shortAssets: shortSyncResults.map(result => this.mapSyncResultToAssetDto(result)),
+            updatedAt: new Date().toISOString()
+        };
+    }
+    /**
+     * Map sync result to PositionAssetDetailDto
+     */
+    mapSyncResultToAssetDto(syncResult) {
+        const currentPrice = this.getMarketPrice(syncResult.asset.coin);
+        const positionValue = syncResult.actualSize * currentPrice;
+        const entryValue = syncResult.actualSize * syncResult.asset.entryPrice;
+        return {
+            ...syncResult.asset,
+            actualSize: syncResult.actualSize,
+            isExternallyModified: syncResult.isExternallyModified,
+            cumFunding: syncResult.cumFunding,
+            marginUsed: entryValue,
+            positionValue: positionValue,
+            unrealizedPnl: syncResult.unrealizedPnl,
+            liquidationPrice: syncResult.liquidationPrice
+        };
+    }
+    /**
+     * Calculate entry ratio (weighted long entry value / weighted short entry value)
+     */
+    calculateEntryRatio(syncResults) {
+        const longResults = syncResults.filter(result => result.side === PositionSide.LONG);
+        const shortResults = syncResults.filter(result => result.side === PositionSide.SHORT);
+        if (longResults.length === 0 || shortResults.length === 0)
+            return 0;
+        // Calculate total position value at entry prices
+        const totalPositionValue = syncResults.reduce((sum, result) => {
+            return sum + (result.actualSize * result.asset.entryPrice);
+        }, 0);
+        if (totalPositionValue === 0)
+            return 0;
+        // Calculate weighted long portfolio entry value
+        const weightedLongValue = longResults.reduce((sum, result) => {
+            const entryPrice = result.asset.entryPrice;
+            const assetValue = result.actualSize * entryPrice;
+            const weight = assetValue / totalPositionValue;
+            return sum + (entryPrice * weight);
+        }, 0);
+        // Calculate weighted short portfolio entry value
+        const weightedShortValue = shortResults.reduce((sum, result) => {
+            const entryPrice = result.asset.entryPrice;
+            const assetValue = result.actualSize * entryPrice;
+            const weight = assetValue / totalPositionValue;
+            return sum + (entryPrice * weight);
+        }, 0);
+        return weightedShortValue > 0 ? weightedLongValue / weightedShortValue : 0;
+    }
+    /**
+     * Calculate mark ratio (weighted long mark value / weighted short mark value)
+     */
+    calculateMarkRatio(syncResults) {
+        const longResults = syncResults.filter(result => result.side === PositionSide.LONG);
+        const shortResults = syncResults.filter(result => result.side === PositionSide.SHORT);
+        if (longResults.length === 0 || shortResults.length === 0)
+            return 0;
+        // Calculate total position value at current market prices
+        const totalPositionValue = syncResults.reduce((sum, result) => {
+            const currentPrice = this.getMarketPrice(result.asset.coin);
+            return sum + (result.actualSize * currentPrice);
+        }, 0);
+        if (totalPositionValue === 0)
+            return 0;
+        // Calculate weighted long portfolio value
+        const weightedLongValue = longResults.reduce((sum, result) => {
+            const currentPrice = this.getMarketPrice(result.asset.coin);
+            const assetValue = result.actualSize * currentPrice;
+            const weight = assetValue / totalPositionValue;
+            return sum + (currentPrice * weight);
+        }, 0);
+        // Calculate weighted short portfolio value
+        const weightedShortValue = shortResults.reduce((sum, result) => {
+            const currentPrice = this.getMarketPrice(result.asset.coin);
+            const assetValue = result.actualSize * currentPrice;
+            const weight = assetValue / totalPositionValue;
+            return sum + (currentPrice * weight);
+        }, 0);
+        return weightedShortValue > 0 ? weightedLongValue / weightedShortValue : 0;
+    }
+    /**
+     * Calculate net funding from sync results
+     */
+    calculateNetFundingFromSyncResults(syncResults) {
+        return syncResults.reduce((sum, result) => sum + result.cumFunding.sinceOpen, 0);
+    }
+    /**
+     * Calculate total unrealized PnL from sync results
+     */
+    calculateTotalUnrealizedPnlFromSyncResults(syncResults) {
+        return syncResults.reduce((sum, result) => sum + result.unrealizedPnl, 0);
+    }
+    /**
+     * Calculate current total position value using market prices
+     */
+    calculateCurrentTotalPositionValue(syncResults) {
+        return syncResults.reduce((sum, result) => {
+            const currentPrice = this.getMarketPrice(result.asset.coin);
+            return sum + (result.actualSize * currentPrice);
+        }, 0);
+    }
+    /**
+     * Calculate entry total position value using entry prices
+     */
+    calculateEntryTotalPositionValue(syncResults) {
+        return syncResults.reduce((sum, result) => {
+            return sum + (result.actualSize * result.asset.entryPrice);
+        }, 0);
+    }
+}
+
+/**
+ * Hook that calculates open positions by syncing platform positions with HyperLiquid real-time data
+ */
+const useCalculatedOpenPositions = (platformPositions, webData2, allMids) => {
+    const calculatedPositions = useMemo(() => {
+        var _a, _b;
+        // Return null if we don't have platform positions yet
+        if (!platformPositions) {
+            console.log('[useCalculatedOpenPositions] No platform positions available');
+            return null;
+        }
+        // If we don't have real-time data yet, return platform positions as-is
+        if (!webData2 || !allMids) {
+            console.log('[useCalculatedOpenPositions] Missing real-time data, returning platform positions');
+            return platformPositions;
+        }
+        console.log('[useCalculatedOpenPositions] Calculating positions with real-time data', {
+            platformPositionsCount: platformPositions.length,
+            hasWebData2: !!webData2,
+            hasAllMids: !!allMids,
+            hyperliquidPositionsCount: ((_b = (_a = webData2.clearinghouseState) === null || _a === void 0 ? void 0 : _a.assetPositions) === null || _b === void 0 ? void 0 : _b.length) || 0,
+            availableMids: Object.keys(allMids.mids || {}).length
+        });
+        // Create calculator and compute positions
+        const calculator = new PositionCalculator(webData2, allMids);
+        const calculated = calculator.calculateOpenPositions(platformPositions);
+        console.log('[useCalculatedOpenPositions] Calculation completed', {
+            inputCount: platformPositions.length,
+            outputCount: calculated.length
+        });
+        return calculated;
+    }, [platformPositions, webData2, allMids]);
+    return calculatedPositions;
+};
+
+/**
+ * Account summary calculation utility class
+ */
+class AccountSummaryCalculator {
+    constructor(webData2) {
+        this.webData2 = webData2;
+    }
+    /**
+     * Calculate account summary from webData2 and platform orders
+     */
+    calculateAccountSummary(platformAccountSummary, platformOpenOrders, agentWalletAddress, agentWalletStatus) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        // If we don't have webData2, return platform data as-is
+        if (!((_a = this.webData2) === null || _a === void 0 ? void 0 : _a.clearinghouseState)) {
+            console.log('[AccountSummaryCalculator] No webData2 clearinghouseState available, returning platform data');
+            return platformAccountSummary;
+        }
+        console.log('[AccountSummaryCalculator] Calculating account summary with real-time data', {
+            hasPlatformSummary: !!platformAccountSummary,
+            hasOpenOrders: !!platformOpenOrders,
+            openOrdersCount: (platformOpenOrders === null || platformOpenOrders === void 0 ? void 0 : platformOpenOrders.length) || 0,
+            hasAgentWallet: !!agentWalletAddress
+        });
+        const clearinghouseState = this.webData2.clearinghouseState;
+        // Calculate total limit order value from platform orders
+        const totalLimitOrderValue = this.calculateTotalLimitOrderValue(platformOpenOrders || []);
+        console.log('[AccountSummaryCalculator] Total limit order value:', totalLimitOrderValue);
+        // Use real-time data from webData2 clearinghouseState
+        const withdrawableAmount = parseFloat(clearinghouseState.withdrawable || '0');
+        const adjustedWithdrawable = Math.max(0, withdrawableAmount - totalLimitOrderValue);
+        const accountSummary = {
+            balanceSummary: {
+                crossMaintenanceMarginUsed: clearinghouseState.crossMaintenanceMarginUsed || '0',
+                crossMarginSummary: {
+                    accountValue: ((_b = clearinghouseState.crossMarginSummary) === null || _b === void 0 ? void 0 : _b.accountValue) || '0',
+                    totalMarginUsed: ((_c = clearinghouseState.crossMarginSummary) === null || _c === void 0 ? void 0 : _c.totalMarginUsed) || '0',
+                    totalNtlPos: ((_d = clearinghouseState.crossMarginSummary) === null || _d === void 0 ? void 0 : _d.totalNtlPos) || '0',
+                    totalRawUsd: ((_e = clearinghouseState.crossMarginSummary) === null || _e === void 0 ? void 0 : _e.totalRawUsd) || '0'
+                },
+                marginSummary: {
+                    accountValue: ((_f = clearinghouseState.marginSummary) === null || _f === void 0 ? void 0 : _f.accountValue) || '0',
+                    totalMarginUsed: ((_g = clearinghouseState.marginSummary) === null || _g === void 0 ? void 0 : _g.totalMarginUsed) || '0',
+                    totalNtlPos: ((_h = clearinghouseState.marginSummary) === null || _h === void 0 ? void 0 : _h.totalNtlPos) || '0',
+                    totalRawUsd: ((_j = clearinghouseState.marginSummary) === null || _j === void 0 ? void 0 : _j.totalRawUsd) || '0'
+                },
+                time: clearinghouseState.time || Date.now(),
+                withdrawable: adjustedWithdrawable.toString()
+            },
+            agentWallet: {
+                address: agentWalletAddress || ((_k = platformAccountSummary === null || platformAccountSummary === void 0 ? void 0 : platformAccountSummary.agentWallet) === null || _k === void 0 ? void 0 : _k.address) || '',
+                status: agentWalletStatus || ((_l = platformAccountSummary === null || platformAccountSummary === void 0 ? void 0 : platformAccountSummary.agentWallet) === null || _l === void 0 ? void 0 : _l.status) || 'UNKNOWN'
+            }
+        };
+        console.log('[AccountSummaryCalculator] Calculated account summary:', {
+            accountValue: accountSummary.balanceSummary.crossMarginSummary.accountValue,
+            withdrawable: accountSummary.balanceSummary.withdrawable,
+            totalMarginUsed: accountSummary.balanceSummary.crossMarginSummary.totalMarginUsed,
+            agentWalletAddress: accountSummary.agentWallet.address
+        });
+        return accountSummary;
+    }
+    /**
+     * Calculate total USD value of open limit orders
+     */
+    calculateTotalLimitOrderValue(openOrders) {
+        if (!(openOrders === null || openOrders === void 0 ? void 0 : openOrders.length)) {
+            return 0;
+        }
+        const totalValue = openOrders
+            .filter(order => order.status === 'OPEN' || order.status === 'PROCESSING')
+            .reduce((sum, order) => sum + order.usdValue, 0);
+        console.log('[AccountSummaryCalculator] Calculated limit order value:', {
+            totalOrders: openOrders.length,
+            openOrders: openOrders.filter(order => order.status === 'OPEN' || order.status === 'PROCESSING').length,
+            totalValue
+        });
+        return totalValue;
+    }
+    /**
+     * Get real-time clearinghouse state from webData2
+     */
+    getClearinghouseState() {
+        var _a;
+        return ((_a = this.webData2) === null || _a === void 0 ? void 0 : _a.clearinghouseState) || null;
+    }
+    /**
+     * Check if real-time data is available
+     */
+    hasRealTimeData() {
+        var _a;
+        return !!((_a = this.webData2) === null || _a === void 0 ? void 0 : _a.clearinghouseState);
+    }
+}
+
+/**
+ * Hook that calculates account summary by syncing platform data with HyperLiquid real-time data
+ */
+const useCalculatedAccountSummary = (platformAccountSummary, platformOpenOrders, webData2, agentWalletAddress, agentWalletStatus) => {
+    const calculatedAccountSummary = useMemo(() => {
+        var _a, _b, _c;
+        // Return null if we don't have platform account summary yet
+        if (!platformAccountSummary) {
+            console.log('[useCalculatedAccountSummary] No platform account summary available');
+            return null;
+        }
+        // If we don't have real-time data yet, return platform summary as-is
+        if (!(webData2 === null || webData2 === void 0 ? void 0 : webData2.clearinghouseState)) {
+            console.log('[useCalculatedAccountSummary] Missing webData2 clearinghouseState, returning platform summary');
+            return platformAccountSummary;
+        }
+        console.log('[useCalculatedAccountSummary] Calculating account summary with real-time data', {
+            hasPlatformSummary: !!platformAccountSummary,
+            hasWebData2: !!webData2,
+            hasClearinghouseState: !!webData2.clearinghouseState,
+            hasOpenOrders: !!platformOpenOrders,
+            openOrdersCount: (platformOpenOrders === null || platformOpenOrders === void 0 ? void 0 : platformOpenOrders.length) || 0,
+            agentWalletAddress,
+            agentWalletStatus
+        });
+        // Create calculator and compute account summary
+        const calculator = new AccountSummaryCalculator(webData2);
+        const calculated = calculator.calculateAccountSummary(platformAccountSummary, platformOpenOrders, agentWalletAddress, agentWalletStatus);
+        console.log('[useCalculatedAccountSummary] Calculation completed', {
+            hadPlatformSummary: !!platformAccountSummary,
+            calculatedSummary: !!calculated,
+            withdrawable: (_a = calculated === null || calculated === void 0 ? void 0 : calculated.balanceSummary) === null || _a === void 0 ? void 0 : _a.withdrawable,
+            accountValue: (_c = (_b = calculated === null || calculated === void 0 ? void 0 : calculated.balanceSummary) === null || _b === void 0 ? void 0 : _b.crossMarginSummary) === null || _c === void 0 ? void 0 : _c.accountValue
+        });
+        return calculated;
+    }, [platformAccountSummary, platformOpenOrders, webData2, agentWalletAddress, agentWalletStatus]);
+    return calculatedAccountSummary;
+};
+
 /**
  * Hook to access trade histories
  */
@@ -5698,74 +3437,16 @@ const useTradeHistories = () => {
     return context.data.tradeHistories;
 };
 /**
- * Hook to access open positions with enhanced real-time synchronization
+ * Hook to access open positions with real-time calculations
  */
 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');
     }
-    // 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
-    };
+    // Use calculated positions that sync platform data with HyperLiquid real-time data
+    const calculatedPositions = useCalculatedOpenPositions(context.data.openPositions, context.webData2, context.allMids);
+    return calculatedPositions;
 };
 /**
  * Hook to access open orders
@@ -5778,85 +3459,18 @@ const useOpenOrders = () => {
     return context.data.openOrders;
 };
 /**
- * Hook to access account summary with enhanced real-time data from Hyperliquid
+ * Hook to access account summary with real-time calculations
  */
 const useAccountSummary = () => {
+    var _a, _b, _c, _d;
     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');
     }
-    // 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
-    };
+    // Use calculated account summary that syncs platform data with HyperLiquid real-time data
+    const calculatedAccountSummary = useCalculatedAccountSummary(context.data.accountSummary, context.data.openOrders, context.webData2, (_b = (_a = context.data.accountSummary) === null || _a === void 0 ? void 0 : _a.agentWallet) === null || _b === void 0 ? void 0 : _b.address, (_d = (_c = context.data.accountSummary) === null || _c === void 0 ? void 0 : _c.agentWallet) === null || _d === void 0 ? void 0 : _d.status);
+    return calculatedAccountSummary;
 };
 
-export { HyperliquidService, PearHyperliquidClient, PearHyperliquidProvider, PearMigrationSDK, PearHyperliquidClient as default, useAccountSummary, useAddress, useHyperliquidService, useMigrationSDK, useOpenOrders, useOpenPositions, usePearHyperliquidClient, useTradeHistories };
+export { AccountSummaryCalculator, PearHyperliquidClient, PearHyperliquidProvider, PearMigrationSDK, PositionCalculator, PositionSide, PearHyperliquidClient as default, useAccountSummary, useAddress, useCalculatedAccountSummary, useCalculatedOpenPositions, useHyperliquidNativeWebSocket, useHyperliquidWebSocket, useMigrationSDK, useOpenOrders, useOpenPositions, usePearHyperliquidClient, useTradeHistories };
 //# sourceMappingURL=index.esm.js.map