@nktkas/hyperliquid 0.24.3 → 0.25.0-beta.2

package/src/src/clients/info.ts

@@ -0,0 +1,2076 @@
+import type { IRequestTransport } from "../transports/base.js";
+import {
+    type ActiveAssetData,
+    ActiveAssetDataRequest,
+    type AllMids,
+    AllMidsRequest,
+    type BlockDetails,
+    BlockDetailsRequest,
+    type BlockDetailsResponse,
+    type Book,
+    type Candle,
+    CandleSnapshotRequest,
+    ClearinghouseStateRequest,
+    type Delegation,
+    DelegationsRequest,
+    DelegatorHistoryRequest,
+    type DelegatorReward,
+    DelegatorRewardsRequest,
+    type DelegatorSummary,
+    DelegatorSummaryRequest,
+    type DelegatorUpdate,
+    type DeployAuctionStatus,
+    type ExchangeStatus,
+    ExchangeStatusRequest,
+    type ExtraAgent,
+    ExtraAgentsRequest,
+    type Fill,
+    FrontendOpenOrdersRequest,
+    type FrontendOrder,
+    type FrontendOrderStatus,
+    type FundingHistory,
+    FundingHistoryRequest,
+    type GossipRootIps,
+    GossipRootIpsRequest,
+    HistoricalOrdersRequest,
+    IsVipRequest,
+    L2BookRequest,
+    LeadingVaultsRequest,
+    type LegalCheck,
+    LegalCheckRequest,
+    LiquidatableRequest,
+    type MarginTable,
+    MarginTableRequest,
+    MaxBuilderFeeRequest,
+    MaxMarketOrderNtlsRequest,
+    MetaAndAssetCtxsRequest,
+    MetaRequest,
+    type MultiSigSigners,
+    OpenOrdersRequest,
+    type Order,
+    type OrderLookup,
+    OrderStatusRequest,
+    parser,
+    PerpDeployAuctionStatusRequest,
+    type PerpDex,
+    type PerpDexLimits,
+    PerpDexLimitsRequest,
+    PerpDexsRequest,
+    PerpsAtOpenInterestCapRequest,
+    type PerpsClearinghouseState,
+    type PerpsMeta,
+    type PerpsMetaAndAssetCtxs,
+    type PortfolioPeriods,
+    PortfolioRequest,
+    type PredictedFunding,
+    PredictedFundingsRequest,
+    type PreTransferCheck,
+    PreTransferCheckRequest,
+    RecentTradesRequest,
+    type Referral,
+    ReferralRequest,
+    type SpotClearinghouseState,
+    SpotClearinghouseStateRequest,
+    type SpotDeployState,
+    SpotDeployStateRequest,
+    type SpotMeta,
+    type SpotMetaAndAssetCtxs,
+    SpotMetaAndAssetCtxsRequest,
+    SpotMetaRequest,
+    SpotPairDeployAuctionStatusRequest,
+    type SubAccount,
+    SubAccountsRequest,
+    type TokenDetails,
+    TokenDetailsRequest,
+    type Trade,
+    type TwapHistory,
+    TwapHistoryRequest,
+    type TwapSliceFill,
+    type TxDetails,
+    TxDetailsRequest,
+    type TxDetailsResponse,
+    UserDetailsRequest,
+    type UserDetailsResponse,
+    type UserFees,
+    UserFeesRequest,
+    UserFillsByTimeRequest,
+    UserFillsRequest,
+    UserFundingRequest,
+    type UserFundingUpdate,
+    type UserNonFundingLedgerUpdate,
+    UserNonFundingLedgerUpdatesRequest,
+    type UserRateLimit,
+    UserRateLimitRequest,
+    type UserRole,
+    UserRoleRequest,
+    UserToMultiSigSignersRequest,
+    UserTwapSliceFillsByTimeRequest,
+    UserTwapSliceFillsRequest,
+    UserVaultEquitiesRequest,
+    type ValidatorL1Vote,
+    ValidatorL1VotesRequest,
+    ValidatorSummariesRequest,
+    type ValidatorSummary,
+    type VaultDetails,
+    VaultDetailsRequest,
+    type VaultEquity,
+    type VaultLeading,
+    VaultSummariesRequest,
+    type VaultSummary,
+} from "../schemas/mod.js";
+
+/** @see https://github.com/microsoft/TypeScript/issues/13923#issuecomment-2191862501 */
+type DeepImmutable<T> = {
+    readonly [K in keyof T]: DeepImmutable<T[K]>;
+};
+
+/** Parameters for the {@linkcode InfoClient} constructor. */
+export interface InfoClientParameters<T extends IRequestTransport = IRequestTransport> {
+    /** The transport used to connect to the Hyperliquid API. */
+    transport: T;
+}
+
+/** Request parameters for the {@linkcode InfoClient.activeAssetData} method. */
+export type ActiveAssetDataParameters = Omit<ActiveAssetDataRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.allMids} method. */
+export type AllMidsParameters = Omit<AllMidsRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.blockDetails} method. */
+export type BlockDetailsParameters = Omit<BlockDetailsRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.candleSnapshot} method. */
+export type CandleSnapshotParameters = CandleSnapshotRequest["req"];
+/** Request parameters for the {@linkcode InfoClient.clearinghouseState} method. */
+export type ClearinghouseStateParameters = Omit<ClearinghouseStateRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.delegations} method. */
+export type DelegationsParameters = Omit<DelegationsRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.delegatorHistory} method. */
+export type DelegatorHistoryParameters = Omit<DelegatorHistoryRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.delegatorRewards} method. */
+export type DelegatorRewardsParameters = Omit<DelegatorRewardsRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.delegatorSummary} method. */
+export type DelegatorSummaryParameters = Omit<DelegatorSummaryRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.extraAgents} method. */
+export type ExtraAgentsParameters = Omit<ExtraAgentsRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.frontendOpenOrders} method. */
+export type FrontendOpenOrdersParameters = Omit<FrontendOpenOrdersRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.fundingHistory} method. */
+export type FundingHistoryParameters = Omit<FundingHistoryRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.historicalOrders} method. */
+export type HistoricalOrdersParameters = Omit<HistoricalOrdersRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.isVip} method. */
+export type IsVipParameters = Omit<IsVipRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.l2Book} method. */
+export type L2BookParameters = Omit<L2BookRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.leadingVaults} method. */
+export type LeadingVaultsParameters = Omit<LeadingVaultsRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.legalCheck} method. */
+export type LegalCheckParameters = Omit<LegalCheckRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.marginTable} method. */
+export type MarginTableParameters = Omit<MarginTableRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.maxBuilderFee} method. */
+export type MaxBuilderFeeParameters = Omit<MaxBuilderFeeRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.meta} method. */
+export type MetaParameters = Omit<MetaRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.metaAndAssetCtxs} method. */
+export type MetaAndAssetCtxsParameters = Omit<MetaAndAssetCtxsRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.openOrders} method. */
+export type OpenOrdersParameters = Omit<OpenOrdersRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.orderStatus} method. */
+export type OrderStatusParameters = Omit<OrderStatusRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.perpDexLimits} method. */
+export type PerpDexLimitsParameters = Omit<PerpDexLimitsRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.perpsAtOpenInterestCap} method. */
+export type PerpsAtOpenInterestCapParameters = Omit<PerpsAtOpenInterestCapRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.portfolio} method. */
+export type PortfolioParameters = Omit<PortfolioRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.preTransferCheck} method. */
+export type PreTransferCheckParameters = Omit<PreTransferCheckRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.recentTrades} method. */
+export type RecentTradesParameters = Omit<RecentTradesRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.referral} method. */
+export type ReferralParameters = Omit<ReferralRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.spotClearinghouseState} method. */
+export type SpotClearinghouseStateParameters = Omit<SpotClearinghouseStateRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.spotDeployState} method. */
+export type SpotDeployStateParameters = Omit<SpotDeployStateRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.subAccounts} method. */
+export type SubAccountsParameters = Omit<SubAccountsRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.tokenDetails} method. */
+export type TokenDetailsParameters = Omit<TokenDetailsRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.twapHistory} method. */
+export type TwapHistoryParameters = Omit<TwapHistoryRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.txDetails} method. */
+export type TxDetailsParameters = Omit<TxDetailsRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.userDetails} method. */
+export type UserDetailsParameters = Omit<UserDetailsRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.userFees} method. */
+export type UserFeesParameters = Omit<UserFeesRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.userFills} method. */
+export type UserFillsParameters = Omit<UserFillsRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.userFillsByTime} method. */
+export type UserFillsByTimeParameters = Omit<UserFillsByTimeRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.userFunding} method. */
+export type UserFundingParameters = Omit<UserFundingRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.userNonFundingLedgerUpdates} method. */
+export type UserNonFundingLedgerUpdatesParameters = Omit<UserNonFundingLedgerUpdatesRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.userRateLimit} method. */
+export type UserRateLimitParameters = Omit<UserRateLimitRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.userRole} method. */
+export type UserRoleParameters = Omit<UserRoleRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.userToMultiSigSigners} method. */
+export type UserToMultiSigSignersParameters = Omit<UserToMultiSigSignersRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.userTwapSliceFills} method. */
+export type UserTwapSliceFillsParameters = Omit<UserTwapSliceFillsRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.userTwapSliceFillsByTime} method. */
+export type UserTwapSliceFillsByTimeParameters = Omit<UserTwapSliceFillsByTimeRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.userVaultEquities} method. */
+export type UserVaultEquitiesParameters = Omit<UserVaultEquitiesRequest, "type">;
+/** Request parameters for the {@linkcode InfoClient.vaultDetails} method. */
+export type VaultDetailsParameters = Omit<VaultDetailsRequest, "type">;
+
+/**
+ * Info client for interacting with the Hyperliquid API.
+ * @typeParam T The type of transport used to connect to the Hyperliquid API.
+ */
+export class InfoClient<
+    T extends IRequestTransport = IRequestTransport,
+> implements InfoClientParameters<T>, AsyncDisposable {
+    transport: T;
+
+    /**
+     * 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: InfoClientParameters<T>) {
+        this.transport = args.transport;
+    }
+
+    /**
+     * Request user active asset data.
+     * @param params - An optional request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns User active asset data.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/perpetuals#retrieve-users-active-asset-data
+     * @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.activeAssetData({ user: "0x...", coin: "ETH" });
+     * ```
+     */
+    activeAssetData(
+        params: DeepImmutable<ActiveAssetDataParameters>,
+        signal?: AbortSignal,
+    ): Promise<ActiveAssetData> {
+        const request = parser(ActiveAssetDataRequest)({
+            type: "activeAssetData",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request mid coin prices.
+     * @param params - An optional request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Mapping of coin symbols to mid prices.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#retrieve-mids-for-all-coins
+     * @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.allMids();
+     * ```
+     */
+    allMids(params?: DeepImmutable<AllMidsParameters>, signal?: AbortSignal): Promise<AllMids>;
+    allMids(signal?: AbortSignal): Promise<AllMids>;
+    allMids(
+        params_or_signal?: DeepImmutable<AllMidsParameters> | AbortSignal,
+        maybeSignal?: AbortSignal,
+    ): Promise<AllMids> {
+        const params = params_or_signal instanceof AbortSignal ? {} : params_or_signal;
+        const signal = params_or_signal instanceof AbortSignal ? params_or_signal : maybeSignal;
+
+        const request = parser(AllMidsRequest)({
+            type: "allMids",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Block details by block height.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Block details.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // only `HttpTransport` supports this method
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.blockDetails({ height: 123 });
+     * ```
+     */
+    blockDetails(
+        // allow only those transports that support `explorer` requests
+        this: T extends { request(endpoint: "explorer", ...args: unknown[]): unknown } ? this : never,
+        params: DeepImmutable<BlockDetailsParameters>,
+        signal?: AbortSignal,
+    ): Promise<BlockDetails> {
+        const request = parser(BlockDetailsRequest)({
+            type: "blockDetails",
+            ...params,
+        });
+        return this.transport.request<BlockDetailsResponse>("explorer", request, signal)
+            .then(({ blockDetails }) => blockDetails);
+    }
+
+    /**
+     * Request candlestick snapshots.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Array of candlestick data points.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params: DeepImmutable<CandleSnapshotParameters>,
+        signal?: AbortSignal,
+    ): Promise<Candle[]> {
+        const request = parser(CandleSnapshotRequest)({
+            type: "candleSnapshot",
+            req: params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request clearinghouse state.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Account summary for perpetual trading.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params: DeepImmutable<ClearinghouseStateParameters>,
+        signal?: AbortSignal,
+    ): Promise<PerpsClearinghouseState> {
+        const request = parser(ClearinghouseStateRequest)({
+            type: "clearinghouseState",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request user staking delegations.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Array of user's delegations to validators.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params: DeepImmutable<DelegationsParameters>,
+        signal?: AbortSignal,
+    ): Promise<Delegation[]> {
+        const request = parser(DelegationsRequest)({
+            type: "delegations",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request user staking history.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Array of user's staking updates.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params: DeepImmutable<DelegatorHistoryParameters>,
+        signal?: AbortSignal,
+    ): Promise<DelegatorUpdate[]> {
+        const request = parser(DelegatorHistoryRequest)({
+            type: "delegatorHistory",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request user staking rewards.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Array of user's staking rewards.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params: DeepImmutable<DelegatorRewardsParameters>,
+        signal?: AbortSignal,
+    ): Promise<DelegatorReward[]> {
+        const request = parser(DelegatorRewardsRequest)({
+            type: "delegatorRewards",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request user staking summary.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Summary of a user's staking delegations.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params: DeepImmutable<DelegatorSummaryParameters>,
+        signal?: AbortSignal,
+    ): Promise<DelegatorSummary> {
+        const request = parser(DelegatorSummaryRequest)({
+            type: "delegatorSummary",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request exchange status information.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Exchange system status information.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @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.exchangeStatus();
+     * ```
+     */
+    exchangeStatus(signal?: AbortSignal): Promise<ExchangeStatus> {
+        const request = parser(ExchangeStatusRequest)({
+            type: "exchangeStatus",
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request user's extra agents.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns User's extra agents.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @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(
+        params: DeepImmutable<ExtraAgentsParameters>,
+        signal?: AbortSignal,
+    ): Promise<ExtraAgent[]> {
+        const request = parser(ExtraAgentsRequest)({
+            type: "extraAgents",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request frontend open orders.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Array of open orders with additional frontend information.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params: DeepImmutable<FrontendOpenOrdersParameters>,
+        signal?: AbortSignal,
+    ): Promise<FrontendOrder[]> {
+        const request = parser(FrontendOpenOrdersRequest)({
+            type: "frontendOpenOrders",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request funding history.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Array of historical funding rate data for an asset.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params: DeepImmutable<FundingHistoryParameters>,
+        signal?: AbortSignal,
+    ): Promise<FundingHistory[]> {
+        const request = parser(FundingHistoryRequest)({
+            type: "fundingHistory",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request gossip root IPs.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Array of gossip root IPs.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @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.gossipRootIps();
+     * ```
+     */
+    gossipRootIps(
+        signal?: AbortSignal,
+    ): Promise<GossipRootIps> {
+        const request = parser(GossipRootIpsRequest)({
+            type: "gossipRootIps",
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request user's historical orders.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Array of user's historical orders.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params: DeepImmutable<HistoricalOrdersParameters>,
+        signal?: AbortSignal,
+    ): Promise<FrontendOrderStatus[]> {
+        const request = parser(HistoricalOrdersRequest)({
+            type: "historicalOrders",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request to check if a user is a VIP.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Boolean indicating user's VIP status.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @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(
+        params: DeepImmutable<IsVipParameters>,
+        signal?: AbortSignal,
+    ): Promise<boolean | null> {
+        const request = parser(IsVipRequest)({
+            type: "isVip",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request L2 order book.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns L2 order book snapshot.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params: DeepImmutable<L2BookParameters>,
+        signal?: AbortSignal,
+    ): Promise<Book> {
+        const request = parser(L2BookRequest)({
+            type: "l2Book",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request leading vaults for a user.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @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.leadingVaults({ user: "0x..." });
+     * ```
+     */
+    leadingVaults(
+        params: DeepImmutable<LeadingVaultsParameters>,
+        signal?: AbortSignal,
+    ): Promise<VaultLeading[]> {
+        const request = parser(LeadingVaultsRequest)({
+            type: "leadingVaults",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request legal verification status of a user.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Legal verification status for a user.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @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(
+        params: DeepImmutable<LegalCheckParameters>,
+        signal?: AbortSignal,
+    ): Promise<LegalCheck> {
+        const request = parser(LegalCheckRequest)({
+            type: "legalCheck",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request liquidatable.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @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.liquidatable();
+     * ```
+     */
+    liquidatable(signal?: AbortSignal): Promise<unknown[]> {
+        const request = parser(LiquidatableRequest)({
+            type: "liquidatable",
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request margin table data.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Margin requirements table with multiple tiers.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @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.marginTable({ id: 1 });
+     * ```
+     */
+    marginTable(
+        params: DeepImmutable<MarginTableParameters>,
+        signal?: AbortSignal,
+    ): Promise<MarginTable> {
+        const request = parser(MarginTableRequest)({
+            type: "marginTable",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request builder fee approval.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Maximum builder fee approval.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params: DeepImmutable<MaxBuilderFeeParameters>,
+        signal?: AbortSignal,
+    ): Promise<number> {
+        const request = parser(MaxBuilderFeeRequest)({
+            type: "maxBuilderFee",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request maximum market order notionals.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @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.maxMarketOrderNtls();
+     * ```
+     */
+    maxMarketOrderNtls(signal?: AbortSignal): Promise<[number, string][]> {
+        const request = parser(MaxMarketOrderNtlsRequest)({
+            type: "maxMarketOrderNtls",
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request trading metadata.
+     * @param params - An optional request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Metadata for perpetual assets.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/perpetuals#retrieve-perpetuals-metadata-universe-and-margin-tables
+     * @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.meta();
+     * ```
+     */
+    meta(params?: DeepImmutable<MetaParameters>, signal?: AbortSignal): Promise<PerpsMeta>;
+    meta(signal?: AbortSignal): Promise<PerpsMeta>;
+    meta(
+        params_or_signal?: DeepImmutable<MetaParameters> | AbortSignal,
+        maybeSignal?: AbortSignal,
+    ): Promise<PerpsMeta> {
+        const params = params_or_signal instanceof AbortSignal ? {} : params_or_signal;
+        const signal = params_or_signal instanceof AbortSignal ? params_or_signal : maybeSignal;
+
+        const request = parser(MetaRequest)({
+            type: "meta",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request metadata and asset contexts.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Metadata and context for perpetual assets.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params?: DeepImmutable<MetaAndAssetCtxsParameters>,
+        signal?: AbortSignal,
+    ): Promise<PerpsMetaAndAssetCtxs>;
+    metaAndAssetCtxs(signal?: AbortSignal): Promise<PerpsMetaAndAssetCtxs>;
+    metaAndAssetCtxs(
+        params_or_signal?: DeepImmutable<MetaAndAssetCtxsParameters> | AbortSignal,
+        maybeSignal?: AbortSignal,
+    ): Promise<PerpsMetaAndAssetCtxs> {
+        const params = params_or_signal instanceof AbortSignal ? {} : params_or_signal;
+        const signal = params_or_signal instanceof AbortSignal ? params_or_signal : maybeSignal;
+
+        const request = parser(MetaAndAssetCtxsRequest)({
+            type: "metaAndAssetCtxs",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request open orders.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Array of open order.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params: DeepImmutable<OpenOrdersParameters>,
+        signal?: AbortSignal,
+    ): Promise<Order[]> {
+        const request = parser(OpenOrdersRequest)({
+            type: "openOrders",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request order status.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Result of an order status lookup.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params: DeepImmutable<OrderStatusParameters>,
+        signal?: AbortSignal,
+    ): Promise<OrderLookup> {
+        const request = parser(OrderStatusRequest)({
+            type: "orderStatus",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request for the status of the perpetual deploy auction.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Status of the perpetual deploy auction.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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?: AbortSignal): Promise<DeployAuctionStatus> {
+        const request = parser(PerpDeployAuctionStatusRequest)({
+            type: "perpDeployAuctionStatus",
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request builder deployed perpetual market limits.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Status of the perpetual deploy auction.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/perpetuals#retrieve-builder-deployed-perp-market-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.perpDexLimits({ dex: "test" });
+     * ```
+     */
+    perpDexLimits(
+        params: DeepImmutable<PerpDexLimitsParameters>,
+        signal?: AbortSignal,
+    ): Promise<PerpDexLimits | null> {
+        const request = parser(PerpDexLimitsRequest)({
+            type: "perpDexLimits",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request all perpetual dexs.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Array of perpetual dexes (null is main dex).
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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?: AbortSignal): Promise<(PerpDex | null)[]> {
+        const request = parser(PerpDexsRequest)({
+            type: "perpDexs",
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request perpetuals at open interest cap.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Array of perpetuals at open interest caps.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params?: DeepImmutable<PerpsAtOpenInterestCapParameters>,
+        signal?: AbortSignal,
+    ): Promise<string[]>;
+    perpsAtOpenInterestCap(signal?: AbortSignal): Promise<string[]>;
+    perpsAtOpenInterestCap(
+        params_or_signal?: DeepImmutable<PerpsAtOpenInterestCapParameters> | AbortSignal,
+        maybeSignal?: AbortSignal,
+    ): Promise<string[]> {
+        const params = params_or_signal instanceof AbortSignal ? {} : params_or_signal;
+        const signal = params_or_signal instanceof AbortSignal ? params_or_signal : maybeSignal;
+
+        const request = parser(PerpsAtOpenInterestCapRequest)({
+            type: "perpsAtOpenInterestCap",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request user portfolio.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Portfolio metrics grouped by time periods.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params: DeepImmutable<PortfolioParameters>,
+        signal?: AbortSignal,
+    ): Promise<PortfolioPeriods> {
+        const request = parser(PortfolioRequest)({
+            type: "portfolio",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request predicted funding rates.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Array of predicted funding rates.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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?: AbortSignal): Promise<PredictedFunding[]> {
+        const request = parser(PredictedFundingsRequest)({
+            type: "predictedFundings",
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request user's existence check before transfer.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Pre-transfer user existence check result.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @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(
+        params: DeepImmutable<PreTransferCheckParameters>,
+        signal?: AbortSignal,
+    ): Promise<PreTransferCheck> {
+        const request = parser(PreTransferCheckRequest)({
+            type: "preTransferCheck",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request recent trades.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Array of recent trades.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @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.recentTrades({ coin: "ETH" });
+     * ```
+     */
+    recentTrades(
+        params: DeepImmutable<RecentTradesParameters>,
+        signal?: AbortSignal,
+    ): Promise<Trade[]> {
+        const request = parser(RecentTradesRequest)({
+            type: "recentTrades",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request user referral.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Referral information for a user.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params: DeepImmutable<ReferralParameters>,
+        signal?: AbortSignal,
+    ): Promise<Referral> {
+        const request = parser(ReferralRequest)({
+            type: "referral",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request spot clearinghouse state.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Account summary for spot trading.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params: DeepImmutable<SpotClearinghouseStateParameters>,
+        signal?: AbortSignal,
+    ): Promise<SpotClearinghouseState> {
+        const request = parser(SpotClearinghouseStateRequest)({
+            type: "spotClearinghouseState",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request spot deploy state.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Deploy state for spot tokens.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params: DeepImmutable<SpotDeployStateParameters>,
+        signal?: AbortSignal,
+    ): Promise<SpotDeployState> {
+        const request = parser(SpotDeployStateRequest)({
+            type: "spotDeployState",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request spot trading metadata.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Metadata for spot assets.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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?: AbortSignal): Promise<SpotMeta> {
+        const request = parser(SpotMetaRequest)({
+            type: "spotMeta",
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request spot metadata and asset contexts.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Metadata and context for spot assets.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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?: AbortSignal): Promise<SpotMetaAndAssetCtxs> {
+        const request = parser(SpotMetaAndAssetCtxsRequest)({
+            type: "spotMetaAndAssetCtxs",
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request for the status of the spot deploy auction.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Status of the spot deploy auction.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/spot#retrieve-information-about-the-spot-pair-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.spotPairDeployAuctionStatus();
+     * ```
+     */
+    spotPairDeployAuctionStatus(signal?: AbortSignal): Promise<DeployAuctionStatus> {
+        const request = parser(SpotPairDeployAuctionStatusRequest)({
+            type: "spotPairDeployAuctionStatus",
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request user sub-accounts.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Array of user sub-account or null if the user does not have any sub-accounts.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params: DeepImmutable<SubAccountsParameters>,
+        signal?: AbortSignal,
+    ): Promise<SubAccount[] | null> {
+        const request = parser(SubAccountsRequest)({
+            type: "subAccounts",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request token details.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Details of a token.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params: DeepImmutable<TokenDetailsParameters>,
+        signal?: AbortSignal,
+    ): Promise<TokenDetails> {
+        const request = parser(TokenDetailsRequest)({
+            type: "tokenDetails",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request twap history of a user.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Array of user's TWAP history.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @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(
+        params: DeepImmutable<TwapHistoryParameters>,
+        signal?: AbortSignal,
+    ): Promise<TwapHistory[]> {
+        const request = parser(TwapHistoryRequest)({
+            type: "twapHistory",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request transaction details by transaction hash.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Transaction details.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // only `HttpTransport` supports this method
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.txDetails({ hash: "0x..." });
+     * ```
+     */
+    txDetails(
+        // allow only those transports that support `explorer` requests
+        this: T extends { request(endpoint: "explorer", ...args: unknown[]): unknown } ? this : never,
+        params: DeepImmutable<TxDetailsParameters>,
+        signal?: AbortSignal,
+    ): Promise<TxDetails> {
+        const request = parser(TxDetailsRequest)({
+            type: "txDetails",
+            ...params,
+        });
+        return this.transport.request<TxDetailsResponse>("explorer", request, signal)
+            .then(({ tx }) => tx);
+    }
+
+    /**
+     * Request user details by user's address.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns User details.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const transport = new hl.HttpTransport(); // only `HttpTransport` supports this method
+     * const infoClient = new hl.InfoClient({ transport });
+     *
+     * const data = await infoClient.userDetails({ user: "0x..." });
+     * ```
+     */
+    userDetails(
+        // allow only those transports that support `explorer` requests
+        this: T extends { request(endpoint: "explorer", ...args: unknown[]): unknown } ? this : never,
+        params: DeepImmutable<UserDetailsParameters>,
+        signal?: AbortSignal,
+    ): Promise<TxDetails[]> {
+        const request = parser(UserDetailsRequest)({
+            type: "userDetails",
+            ...params,
+        });
+        return this.transport.request<UserDetailsResponse>("explorer", request, signal)
+            .then(({ txs }) => txs);
+    }
+
+    /**
+     * Request user fees.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns User fees.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#query-a-users-fees
+     * @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(
+        params: DeepImmutable<UserFeesParameters>,
+        signal?: AbortSignal,
+    ): Promise<UserFees> {
+        const request = parser(UserFeesRequest)({
+            type: "userFees",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request user fills.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Array of user's trade fill.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params: DeepImmutable<UserFillsParameters>,
+        signal?: AbortSignal,
+    ): Promise<Fill[]> {
+        const request = parser(UserFillsRequest)({
+            type: "userFills",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request user fills by time.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Array of user's trade fill.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params: DeepImmutable<UserFillsByTimeParameters>,
+        signal?: AbortSignal,
+    ): Promise<Fill[]> {
+        const request = parser(UserFillsByTimeRequest)({
+            type: "userFillsByTime",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request user funding.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Array of user's funding ledger update.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params: DeepImmutable<UserFundingParameters>,
+        signal?: AbortSignal,
+    ): Promise<UserFundingUpdate[]> {
+        const request = parser(UserFundingRequest)({
+            type: "userFunding",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request user non-funding ledger updates.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Array of user's non-funding ledger update.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params: DeepImmutable<UserNonFundingLedgerUpdatesParameters>,
+        signal?: AbortSignal,
+    ): Promise<UserNonFundingLedgerUpdate[]> {
+        const request = parser(UserNonFundingLedgerUpdatesRequest)({
+            type: "userNonFundingLedgerUpdates",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request user rate limits.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns User's rate limits.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params: DeepImmutable<UserRateLimitParameters>,
+        signal?: AbortSignal,
+    ): Promise<UserRateLimit> {
+        const request = parser(UserRateLimitRequest)({
+            type: "userRateLimit",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request user role.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns User's role.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params: DeepImmutable<UserRoleParameters>,
+        signal?: AbortSignal,
+    ): Promise<UserRole> {
+        const request = parser(UserRoleRequest)({
+            type: "userRole",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request multi-sig signers for a user.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Multi-sig signers for a user or null if the user does not have any multi-sig signers.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @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(
+        params: DeepImmutable<UserToMultiSigSignersParameters>,
+        signal?: AbortSignal,
+    ): Promise<MultiSigSigners | null> {
+        const request = parser(UserToMultiSigSignersRequest)({
+            type: "userToMultiSigSigners",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request user twap slice fills.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Array of user's twap slice fill.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params: DeepImmutable<UserTwapSliceFillsParameters>,
+        signal?: AbortSignal,
+    ): Promise<TwapSliceFill[]> {
+        const request = parser(UserTwapSliceFillsRequest)({
+            type: "userTwapSliceFills",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request user twap slice fills by time.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Array of user's twap slice fill.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @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(
+        params: DeepImmutable<UserTwapSliceFillsByTimeParameters>,
+        signal?: AbortSignal,
+    ): Promise<TwapSliceFill[]> {
+        const request = parser(UserTwapSliceFillsByTimeRequest)({
+            type: "userTwapSliceFillsByTime",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request user vault deposits.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Array of user's vault deposits.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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.userVaultEquities({ user: "0x..." });
+     * ```
+     */
+    userVaultEquities(
+        params: DeepImmutable<UserVaultEquitiesParameters>,
+        signal?: AbortSignal,
+    ): Promise<VaultEquity[]> {
+        const request = parser(UserVaultEquitiesRequest)({
+            type: "userVaultEquities",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request validator L1 votes.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @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.validatorL1Votes();
+     * ```
+     */
+    validatorL1Votes(signal?: AbortSignal): Promise<ValidatorL1Vote[]> {
+        const request = parser(ValidatorL1VotesRequest)({
+            type: "validatorL1Votes",
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request validator summaries.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Array of validator summaries.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @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?: AbortSignal): Promise<ValidatorSummary[]> {
+        const request = parser(ValidatorSummariesRequest)({
+            type: "validatorSummaries",
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request details of a vault.
+     * @param params - Request-specific parameters.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Details of a vault or null if the vault does not exist.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @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(
+        params: DeepImmutable<VaultDetailsParameters>,
+        signal?: AbortSignal,
+    ): Promise<VaultDetails | null> {
+        const request = parser(VaultDetailsRequest)({
+            type: "vaultDetails",
+            ...params,
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    /**
+     * Request a list of vaults less than 2 hours old.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns Array of vault summaries.
+     *
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @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?: AbortSignal): Promise<VaultSummary[]> {
+        const request = parser(VaultSummariesRequest)({
+            type: "vaultSummaries",
+        });
+        return this.transport.request("info", request, signal);
+    }
+
+    async [Symbol.asyncDispose](): Promise<void> {
+        await this.transport[Symbol.asyncDispose]?.();
+    }
+}