@nktkas/hyperliquid 0.24.3 → 0.25.0-beta.2

package/src/src/clients/exchange.ts

@@ -0,0 +1,2246 @@
+import { HyperliquidError } from "../errors.js";
+import type { IRequestTransport } from "../transports/base.js";
+import {
+    ApproveAgentRequest,
+    ApproveBuilderFeeRequest,
+    BatchModifyRequest,
+    CancelByCloidRequest,
+    CancelRequest,
+    type CancelResponse,
+    type CancelSuccessResponse,
+    CDepositRequest,
+    ClaimRewardsRequest,
+    ConvertToMultiSigUserRequest,
+    type ConvertToMultiSigUserRequestSigners,
+    CreateSubAccountRequest,
+    type CreateSubAccountResponse,
+    CreateVaultRequest,
+    type CreateVaultResponse,
+    CSignerActionRequest,
+    CValidatorActionRequest,
+    CWithdrawRequest,
+    type ErrorResponse,
+    EvmUserModifyRequest,
+    ModifyRequest,
+    MultiSigRequest,
+    NoopRequest,
+    OrderRequest,
+    type OrderResponse,
+    type OrderSuccessResponse,
+    parser,
+    PerpDeployRequest,
+    RegisterReferrerRequest,
+    ReserveRequestWeightRequest,
+    ScheduleCancelRequest,
+    SendAssetRequest,
+    SetDisplayNameRequest,
+    SetReferrerRequest,
+    SpotDeployRequest,
+    SpotSendRequest,
+    SpotUserRequest,
+    SubAccountModifyRequest,
+    SubAccountSpotTransferRequest,
+    SubAccountTransferRequest,
+    type SuccessResponse,
+    TokenDelegateRequest,
+    TwapCancelRequest,
+    type TwapCancelResponse,
+    type TwapCancelSuccessResponse,
+    TwapOrderRequest,
+    type TwapOrderResponse,
+    type TwapOrderSuccessResponse,
+    UpdateIsolatedMarginRequest,
+    UpdateLeverageRequest,
+    UsdClassTransferRequest,
+    UsdSendRequest,
+    VaultDistributeRequest,
+    VaultModifyRequest,
+    VaultTransferRequest,
+    Withdraw3Request,
+} from "../schemas/mod.js";
+import {
+    type AbstractWallet,
+    getWalletChainId,
+    signL1Action,
+    signMultiSigAction,
+    signUserSignedAction,
+    userSignedActionEip712Types,
+} from "../signing/mod.js";
+
+type MaybePromise<T> = T | Promise<T>;
+
+/** @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 ExchangeClient} constructor. */
+export interface ExchangeClientParameters<
+    T extends IRequestTransport = IRequestTransport,
+    W extends AbstractWallet = AbstractWallet,
+> {
+    /** The transport used to connect to the Hyperliquid API. */
+    transport: T;
+    /** The viem or ethers.js wallet used for signing transactions. */
+    wallet: W;
+    /** Sets a default vaultAddress to be used if no vaultAddress is explicitly passed to a method. */
+    defaultVaultAddress?: `0x${string}`;
+    /** Sets a default expiresAfter to be used if no expiresAfter is explicitly passed to a method. */
+    defaultExpiresAfter?: number | (() => MaybePromise<number>);
+    /**
+     * The network that will be used to sign transactions.
+     * Must match the network of the {@link wallet}.
+     *
+     * Defaults to get chain id from wallet otherwise `0x1`.
+     */
+    signatureChainId?: `0x${string}` | (() => MaybePromise<`0x${string}`>);
+    /**
+     * Function to get the next nonce for signing transactions.
+     *
+     * Defaults to a function that returns the current timestamp or, if duplicated, increments the last nonce.
+     */
+    nonceManager?: () => MaybePromise<number>;
+}
+
+// deno-lint-ignore no-explicit-any
+type DistributiveOmit<T, K extends keyof any> = T extends unknown ? Omit<T, K> : never;
+type ExtractRequestAction<T extends { action: Record<string, unknown> }> = T["action"] extends
+    { signatureChainId: unknown }
+    ? DistributiveOmit<T["action"], "type" | "signatureChainId" | "hyperliquidChain" | "nonce" | "time"> // user-signed actions
+    : DistributiveOmit<T["action"], "type">; // L1 actions
+/** Action parameters for the {@linkcode ExchangeClient.approveAgent} method. */
+export type ApproveAgentParameters = ExtractRequestAction<ApproveAgentRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.approveBuilderFee} method. */
+export type ApproveBuilderFeeParameters = ExtractRequestAction<ApproveBuilderFeeRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.batchModify} method. */
+export type BatchModifyParameters = ExtractRequestAction<BatchModifyRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.cancel} method. */
+export type CancelParameters = ExtractRequestAction<CancelRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.cancelByCloid} method. */
+export type CancelByCloidParameters = ExtractRequestAction<CancelByCloidRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.cDeposit} method. */
+export type CDepositParameters = ExtractRequestAction<CDepositRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.convertToMultiSigUser} method. */
+export type ConvertToMultiSigUserParameters =
+    & Omit<ExtractRequestAction<ConvertToMultiSigUserRequest>, "signers">
+    & {
+        /** Signers configuration. */
+        signers: ConvertToMultiSigUserRequestSigners;
+    };
+/** Action parameters for the {@linkcode ExchangeClient.createSubAccount} method. */
+export type CreateSubAccountParameters = ExtractRequestAction<CreateSubAccountRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.createVault} method. */
+export type CreateVaultParameters = ExtractRequestAction<CreateVaultRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.cSignerAction} method. */
+export type CSignerActionParameters = ExtractRequestAction<CSignerActionRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.cValidatorAction} method. */
+export type CValidatorActionParameters = ExtractRequestAction<CValidatorActionRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.cWithdraw} method. */
+export type CWithdrawParameters = ExtractRequestAction<CWithdrawRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.evmUserModify} method. */
+export type EvmUserModifyParameters = ExtractRequestAction<EvmUserModifyRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.modify} method. */
+export type ModifyParameters = ExtractRequestAction<ModifyRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.multiSig} method. */
+export type MultiSigParameters = ExtractRequestAction<MultiSigRequest> & Pick<MultiSigRequest, "nonce">;
+/** Action parameters for the {@linkcode ExchangeClient.order} method. */
+export type OrderParameters = ExtractRequestAction<OrderRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.perpDeploy} method. */
+export type PerpDeployParameters = ExtractRequestAction<PerpDeployRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.registerReferrer} method. */
+export type RegisterReferrerParameters = ExtractRequestAction<RegisterReferrerRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.reserveRequestWeight} method. */
+export type ReserveRequestWeightParameters = ExtractRequestAction<ReserveRequestWeightRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.scheduleCancel} method. */
+export type ScheduleCancelParameters = ExtractRequestAction<ScheduleCancelRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.sendAsset} method. */
+export type SendAssetParameters = ExtractRequestAction<SendAssetRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.setDisplayName} method. */
+export type SetDisplayNameParameters = ExtractRequestAction<SetDisplayNameRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.setReferrer} method. */
+export type SetReferrerParameters = ExtractRequestAction<SetReferrerRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.spotDeploy} method. */
+export type SpotDeployParameters = ExtractRequestAction<SpotDeployRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.spotSend} method. */
+export type SpotSendParameters = ExtractRequestAction<SpotSendRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.spotUser} method. */
+export type SpotUserParameters = ExtractRequestAction<SpotUserRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.subAccountModify} method. */
+export type SubAccountModifyParameters = ExtractRequestAction<SubAccountModifyRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.subAccountSpotTransfer} method. */
+export type SubAccountSpotTransferParameters = ExtractRequestAction<SubAccountSpotTransferRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.subAccountTransfer} method. */
+export type SubAccountTransferParameters = ExtractRequestAction<SubAccountTransferRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.tokenDelegate} method. */
+export type TokenDelegateParameters = ExtractRequestAction<TokenDelegateRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.twapCancel} method. */
+export type TwapCancelParameters = ExtractRequestAction<TwapCancelRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.twapOrder} method. */
+export type TwapOrderParameters = ExtractRequestAction<TwapOrderRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.updateIsolatedMargin} method. */
+export type UpdateIsolatedMarginParameters = ExtractRequestAction<UpdateIsolatedMarginRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.updateLeverage} method. */
+export type UpdateLeverageParameters = ExtractRequestAction<UpdateLeverageRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.usdClassTransfer} method. */
+export type UsdClassTransferParameters = ExtractRequestAction<UsdClassTransferRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.usdSend} method. */
+export type UsdSendParameters = ExtractRequestAction<UsdSendRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.vaultDistribute} method. */
+export type VaultDistributeParameters = ExtractRequestAction<VaultDistributeRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.vaultModify} method. */
+export type VaultModifyParameters = ExtractRequestAction<VaultModifyRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.vaultTransfer} method. */
+export type VaultTransferParameters = ExtractRequestAction<VaultTransferRequest>;
+/** Action parameters for the {@linkcode ExchangeClient.withdraw3} method. */
+export type Withdraw3Parameters = ExtractRequestAction<Withdraw3Request>;
+
+interface BaseRequestOptions {
+    /**
+     * 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}.
+     */
+    signal?: AbortSignal;
+}
+type ExtractRequestOptions<T extends { action: Record<string, unknown> }> =
+    & BaseRequestOptions
+    & Omit<T, "action" | "nonce" | "signature">;
+/** Request options for the {@linkcode ExchangeClient.approveAgent} method. */
+export type ApproveAgentOptions = ExtractRequestOptions<ApproveAgentRequest>;
+/** Request options for the {@linkcode ExchangeClient.approveBuilderFee} method. */
+export type ApproveBuilderFeeOptions = ExtractRequestOptions<ApproveBuilderFeeRequest>;
+/** Request options for the {@linkcode ExchangeClient.batchModify} method. */
+export type BatchModifyOptions = ExtractRequestOptions<BatchModifyRequest>;
+/** Request options for the {@linkcode ExchangeClient.cancel} method. */
+export type CancelOptions = ExtractRequestOptions<CancelRequest>;
+/** Request options for the {@linkcode ExchangeClient.cancelByCloid} method. */
+export type CancelByCloidOptions = ExtractRequestOptions<CancelByCloidRequest>;
+/** Request options for the {@linkcode ExchangeClient.cDeposit} method. */
+export type CDepositOptions = ExtractRequestOptions<CDepositRequest>;
+/** Request options for the {@linkcode ExchangeClient.claimRewards} method. */
+export type ClaimRewardsOptions = ExtractRequestOptions<ClaimRewardsRequest>;
+/** Request options for the {@linkcode ExchangeClient.convertToMultiSigUser} method. */
+export type ConvertToMultiSigUserOptions = ExtractRequestOptions<ConvertToMultiSigUserRequest>;
+/** Request options for the {@linkcode ExchangeClient.createSubAccount} method. */
+export type CreateSubAccountOptions = ExtractRequestOptions<CreateSubAccountRequest>;
+/** Request options for the {@linkcode ExchangeClient.createVault} method. */
+export type CreateVaultOptions = ExtractRequestOptions<CreateVaultRequest>;
+/** Request options for the {@linkcode ExchangeClient.cSignerAction} method. */
+export type CSignerActionOptions = ExtractRequestOptions<CSignerActionRequest>;
+/** Request options for the {@linkcode ExchangeClient.cValidatorAction} method. */
+export type CValidatorActionOptions = ExtractRequestOptions<CValidatorActionRequest>;
+/** Request options for the {@linkcode ExchangeClient.cWithdraw} method. */
+export type CWithdrawOptions = ExtractRequestOptions<CWithdrawRequest>;
+/** Request options for the {@linkcode ExchangeClient.evmUserModify} method. */
+export type EvmUserModifyOptions = ExtractRequestOptions<EvmUserModifyRequest>;
+/** Request options for the {@linkcode ExchangeClient.modify} method. */
+export type ModifyOptions = ExtractRequestOptions<ModifyRequest>;
+/** Request options for the {@linkcode ExchangeClient.multiSig} method. */
+export type MultiSigOptions = ExtractRequestOptions<MultiSigRequest>;
+/** Request options for the {@linkcode ExchangeClient.noop} method. */
+export type NoopOptions = ExtractRequestOptions<NoopRequest>;
+/** Request options for the {@linkcode ExchangeClient.order} method. */
+export type OrderOptions = ExtractRequestOptions<OrderRequest>;
+/** Request options for the {@linkcode ExchangeClient.perpDeploy} method. */
+export type PerpDeployOptions = ExtractRequestOptions<PerpDeployRequest>;
+/** Request options for the {@linkcode ExchangeClient.registerReferrer} method. */
+export type RegisterReferrerOptions = ExtractRequestOptions<RegisterReferrerRequest>;
+/** Request options for the {@linkcode ExchangeClient.reserveRequestWeight} method. */
+export type ReserveRequestWeightOptions = ExtractRequestOptions<ReserveRequestWeightRequest>;
+/** Request options for the {@linkcode ExchangeClient.scheduleCancel} method. */
+export type ScheduleCancelOptions = ExtractRequestOptions<ScheduleCancelRequest>;
+/** Request options for the {@linkcode ExchangeClient.sendAsset} method. */
+export type SendAssetOptions = ExtractRequestOptions<SendAssetRequest>;
+/** Request options for the {@linkcode ExchangeClient.setDisplayName} method. */
+export type SetDisplayNameOptions = ExtractRequestOptions<SetDisplayNameRequest>;
+/** Request options for the {@linkcode ExchangeClient.setReferrer} method. */
+export type SetReferrerOptions = ExtractRequestOptions<SetReferrerRequest>;
+/** Request options for the {@linkcode ExchangeClient.spotDeploy} method. */
+export type SpotDeployOptions = ExtractRequestOptions<SpotDeployRequest>;
+/** Request options for the {@linkcode ExchangeClient.spotSend} method. */
+export type SpotSendOptions = ExtractRequestOptions<SpotSendRequest>;
+/** Request options for the {@linkcode ExchangeClient.spotUser} method. */
+export type SpotUserOptions = ExtractRequestOptions<SpotUserRequest>;
+/** Request options for the {@linkcode ExchangeClient.subAccountModify} method. */
+export type SubAccountModifyOptions = ExtractRequestOptions<SubAccountModifyRequest>;
+/** Request options for the {@linkcode ExchangeClient.subAccountSpotTransfer} method. */
+export type SubAccountSpotTransferOptions = ExtractRequestOptions<SubAccountSpotTransferRequest>;
+/** Request options for the {@linkcode ExchangeClient.subAccountTransfer} method. */
+export type SubAccountTransferOptions = ExtractRequestOptions<SubAccountTransferRequest>;
+/** Request options for the {@linkcode ExchangeClient.tokenDelegate} method. */
+export type TokenDelegateOptions = ExtractRequestOptions<TokenDelegateRequest>;
+/** Request options for the {@linkcode ExchangeClient.twapCancel} method. */
+export type TwapCancelOptions = ExtractRequestOptions<TwapCancelRequest>;
+/** Request options for the {@linkcode ExchangeClient.twapOrder} method. */
+export type TwapOrderOptions = ExtractRequestOptions<TwapOrderRequest>;
+/** Request options for the {@linkcode ExchangeClient.updateIsolatedMargin} method. */
+export type UpdateIsolatedMarginOptions = ExtractRequestOptions<UpdateIsolatedMarginRequest>;
+/** Request options for the {@linkcode ExchangeClient.updateLeverage} method. */
+export type UpdateLeverageOptions = ExtractRequestOptions<UpdateLeverageRequest>;
+/** Request options for the {@linkcode ExchangeClient.usdClassTransfer} method. */
+export type UsdClassTransferOptions = ExtractRequestOptions<UsdClassTransferRequest>;
+/** Request options for the {@linkcode ExchangeClient.usdSend} method. */
+export type UsdSendOptions = ExtractRequestOptions<UsdSendRequest>;
+/** Request options for the {@linkcode ExchangeClient.vaultDistribute} method. */
+export type VaultDistributeOptions = ExtractRequestOptions<VaultDistributeRequest>;
+/** Request options for the {@linkcode ExchangeClient.vaultModify} method. */
+export type VaultModifyOptions = ExtractRequestOptions<VaultModifyRequest>;
+/** Request options for the {@linkcode ExchangeClient.vaultTransfer} method. */
+export type VaultTransferOptions = ExtractRequestOptions<VaultTransferRequest>;
+/** Request options for the {@linkcode ExchangeClient.withdraw3} method. */
+export type Withdraw3Options = ExtractRequestOptions<Withdraw3Request>;
+
+/** Thrown when an API request fails. */
+export class ApiRequestError extends HyperliquidError {
+    constructor(
+        public response:
+            | ErrorResponse
+            | OrderResponse
+            | CancelResponse
+            | TwapOrderResponse
+            | TwapCancelResponse,
+    ) {
+        let message;
+        if (response.status === "err") {
+            // ErrorResponse
+            message = response.response;
+        } else {
+            if ("statuses" in response.response.data) {
+                // OrderResponse | CancelResponse
+                const errors = response.response.data.statuses.reduce<string[]>((acc, status, index) => {
+                    if (typeof status === "object" && "error" in status) {
+                        acc.push(`Order ${index}: ${status.error}`);
+                    }
+                    return acc;
+                }, []);
+                if (errors.length > 0) {
+                    message = errors.join(", ");
+                }
+            } else {
+                // TwapOrderResponse | TwapCancelResponse
+                if (typeof response.response.data.status === "object" && "error" in response.response.data.status) {
+                    message = response.response.data.status.error;
+                }
+            }
+        }
+
+        super(message || "An unknown error occurred while processing an API request. See `response` for more details.");
+        this.name = "ApiRequestError";
+    }
+}
+
+/** Nonce manager for generating unique nonces for signing transactions. */
+class NonceManager {
+    /** The last nonce used for signing transactions. */
+    private lastNonce = 0;
+
+    /**
+     * Gets the next nonce for signing transactions.
+     * @returns The next nonce.
+     */
+    getNonce(): number {
+        let nonce = Date.now();
+        if (nonce <= this.lastNonce) {
+            nonce = ++this.lastNonce;
+        } else {
+            this.lastNonce = nonce;
+        }
+        return nonce;
+    }
+}
+
+/**
+ * Exchange client for interacting with the Hyperliquid API.
+ * @typeParam T The transport used to connect to the Hyperliquid API.
+ * @typeParam W The wallet used for signing transactions.
+ */
+export class ExchangeClient<
+    T extends IRequestTransport = IRequestTransport,
+    W extends AbstractWallet = AbstractWallet,
+> implements ExchangeClientParameters<T, W>, AsyncDisposable {
+    transport: T;
+    wallet: W;
+    defaultVaultAddress?: `0x${string}`;
+    defaultExpiresAfter?: number | (() => MaybePromise<number>);
+    signatureChainId: `0x${string}` | (() => MaybePromise<`0x${string}`>);
+    nonceManager: () => MaybePromise<number>;
+
+    /**
+     * Initialises a new instance.
+     * @param args - The parameters for the client.
+     *
+     * @example Private key directly
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x...";
+     *
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     * ```
+     *
+     * @example [Viem](https://viem.sh/docs/clients/wallet#local-accounts-private-key-mnemonic-etc)
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     * import { privateKeyToAccount } from "npm:viem/accounts";
+     *
+     * const account = privateKeyToAccount("0x...");
+     *
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: account, transport });
+     * ```
+     *
+     * @example [ethers.js](https://docs.ethers.org/v6/api/wallet/#Wallet) or [ethers.js v5](https://docs.ethers.org/v5/api/signer/#Wallet)
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     * import { ethers } from "npm:ethers";
+     *
+     * const wallet = new ethers.Wallet("0x...");
+     *
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet, transport });
+     * ```
+     *
+     * @example External wallet (e.g. MetaMask) via [viem](https://viem.sh/docs/clients/wallet)
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     * import { createWalletClient, custom } from "npm:viem";
+     *
+     * const ethereum = (window as any).ethereum;
+     * const [account] = await ethereum.request({ method: "eth_requestAccounts" }) as `0x${string}`[];
+     * const wallet = createWalletClient({ account, transport: custom(ethereum) });
+     *
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet, transport });
+     * ```
+     */
+    constructor(args: ExchangeClientParameters<T, W>) {
+        this.transport = args.transport;
+        this.wallet = args.wallet;
+        this.defaultVaultAddress = args.defaultVaultAddress;
+        this.defaultExpiresAfter = args.defaultExpiresAfter;
+        this.signatureChainId = args.signatureChainId ?? (() => getWalletChainId(this.wallet));
+        this.nonceManager = args.nonceManager ?? new NonceManager().getNonce;
+    }
+
+    /**
+     * Approve an agent to sign on behalf of the master account.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#approve-an-api-wallet
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.approveAgent({ agentAddress: "0x...", agentName: "..." });
+     * ```
+     */
+    async approveAgent(
+        params: DeepImmutable<ApproveAgentParameters>,
+        opts?: ApproveAgentOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(ApproveAgentRequest.entries.action)({
+            type: "approveAgent",
+            hyperliquidChain: this._getHyperliquidChain(),
+            signatureChainId: await this._getSignatureChainId(),
+            nonce: await this.nonceManager(),
+            ...params,
+        });
+        return await this._executeUserSignedAction({ action }, opts?.signal);
+    }
+
+    /**
+     * Approve a maximum fee rate for a builder.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#approve-a-builder-fee
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.approveBuilderFee({ maxFeeRate: "0.01%", builder: "0x..." });
+     * ```
+     */
+    async approveBuilderFee(
+        params: DeepImmutable<ApproveBuilderFeeParameters>,
+        opts?: ApproveBuilderFeeOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(ApproveBuilderFeeRequest.entries.action)({
+            type: "approveBuilderFee",
+            hyperliquidChain: this._getHyperliquidChain(),
+            signatureChainId: await this._getSignatureChainId(),
+            nonce: await this.nonceManager(),
+            ...params,
+        });
+        return await this._executeUserSignedAction({ action }, opts?.signal);
+    }
+
+    /**
+     * Modify multiple orders.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful variant of {@link OrderResponse} without error statuses.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#modify-multiple-orders
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * const data = await exchClient.batchModify({
+     *   modifies: [
+     *     {
+     *       oid: 123,
+     *       order: {
+     *         a: 0,
+     *         b: true,
+     *         p: "31000",
+     *         s: "0.2",
+     *         r: false,
+     *         t: { limit: { tif: "Gtc" } },
+     *       },
+     *     },
+     *   ],
+     * });
+     * ```
+     */
+    async batchModify(
+        params: DeepImmutable<BatchModifyParameters>,
+        opts?: BatchModifyOptions,
+    ): Promise<OrderSuccessResponse> {
+        const action = parser(BatchModifyRequest.entries.action)({
+            type: "batchModify",
+            ...params,
+        });
+        const vaultAddress = opts?.vaultAddress ?? this.defaultVaultAddress;
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, vaultAddress, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * Cancel order(s).
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful variant of {@link CancelResponse} without error statuses.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#cancel-order-s
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * const data = await exchClient.cancel({
+     *   cancels: [
+     *     { a: 0, o: 123 },
+     *   ],
+     * });
+     * ```
+     */
+    async cancel(
+        params: DeepImmutable<CancelParameters>,
+        opts?: CancelOptions,
+    ): Promise<CancelSuccessResponse> {
+        const action = parser(CancelRequest.entries.action)({
+            type: "cancel",
+            ...params,
+        });
+        const vaultAddress = opts?.vaultAddress ?? this.defaultVaultAddress;
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, vaultAddress, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * Cancel order(s) by cloid.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful variant of {@link CancelResponse} without error statuses.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#cancel-order-s-by-cloid
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * const data = await exchClient.cancelByCloid({
+     *   cancels: [
+     *     { asset: 0, cloid: "0x..." },
+     *   ],
+     * });
+     * ```
+     */
+    async cancelByCloid(
+        params: DeepImmutable<CancelByCloidParameters>,
+        opts?: CancelByCloidOptions,
+    ): Promise<CancelSuccessResponse> {
+        const action = parser(CancelByCloidRequest.entries.action)({
+            type: "cancelByCloid",
+            ...params,
+        });
+        const vaultAddress = opts?.vaultAddress ?? this.defaultVaultAddress;
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, vaultAddress, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * Transfer native token from the user's spot account into staking for delegating to validators.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#deposit-into-staking
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.cDeposit({ wei: 1 * 1e8 });
+     * ```
+     */
+    async cDeposit(
+        params: DeepImmutable<CDepositParameters>,
+        opts?: CDepositOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(CDepositRequest.entries.action)({
+            type: "cDeposit",
+            hyperliquidChain: this._getHyperliquidChain(),
+            signatureChainId: await this._getSignatureChainId(),
+            nonce: await this.nonceManager(),
+            ...params,
+        });
+        return await this._executeUserSignedAction({ action }, opts?.signal);
+    }
+
+    /**
+     * Claim rewards from referral program.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.claimRewards();
+     * ```
+     */
+    async claimRewards(
+        opts?: ClaimRewardsOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(ClaimRewardsRequest.entries.action)({
+            type: "claimRewards",
+        });
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * Convert a single-signature account to a multi-signature account or vice versa.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/hypercore/multi-sig
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * // Convert to multi-sig user
+     * await exchClient.convertToMultiSigUser({
+     *   signers: {
+     *     authorizedUsers: ["0x...", "0x...", "0x..."],
+     *     threshold: 2,
+     *   },
+     * });
+     *
+     * // Convert to single-sig user
+     * await exchClient.convertToMultiSigUser({ signers: null });
+     * ```
+     */
+    async convertToMultiSigUser(
+        params: DeepImmutable<ConvertToMultiSigUserParameters>,
+        opts?: ConvertToMultiSigUserOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(ConvertToMultiSigUserRequest.entries.action)({
+            type: "convertToMultiSigUser",
+            hyperliquidChain: this._getHyperliquidChain(),
+            signatureChainId: await this._getSignatureChainId(),
+            nonce: await this.nonceManager(),
+            ...params,
+        });
+        return await this._executeUserSignedAction({ action }, opts?.signal);
+    }
+
+    /**
+     * Create a sub-account.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Response for creating a sub-account.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * const data = await exchClient.createSubAccount({ name: "..." });
+     * ```
+     */
+    async createSubAccount(
+        params: DeepImmutable<CreateSubAccountParameters>,
+        opts?: CreateSubAccountOptions,
+    ): Promise<CreateSubAccountResponse> {
+        const action = parser(CreateSubAccountRequest.entries.action)({
+            type: "createSubAccount",
+            ...params,
+        });
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * Create a vault.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Response for creating a vault.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * const data = await exchClient.createVault({
+     *   name: "...",
+     *   description: "...",
+     *   initialUsd: 100 * 1e6,
+     *   nonce: Date.now(),
+     * });
+     * ```
+     */
+    async createVault(
+        params: DeepImmutable<CreateVaultParameters>,
+        opts?: CreateVaultOptions,
+    ): Promise<CreateVaultResponse> {
+        const action = parser(CreateVaultRequest.entries.action)({
+            type: "createVault",
+            ...params,
+        });
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * Jail or unjail self as a validator signer.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * // Jail self
+     * await exchClient.cSignerAction({ jailSelf: null });
+     *
+     * // Unjail self
+     * await exchClient.cSignerAction({ unjailSelf: null });
+     * ```
+     */
+    async cSignerAction(
+        params: DeepImmutable<CSignerActionParameters>,
+        opts?: CSignerActionOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(CSignerActionRequest.entries.action)({
+            type: "CSignerAction",
+            ...params,
+        });
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * Action related to validator management.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * // Change validator profile
+     * await exchClient.cValidatorAction({
+     *   changeProfile: {
+     *     node_ip: { Ip: "1.2.3.4" },
+     *     name: "...",
+     *     description: "...",
+     *     unjailed: true,
+     *     disable_delegations: false,
+     *     commission_bps: null,
+     *     signer: null,
+     *   },
+     * });
+     *
+     * // Register a new validator
+     * await exchClient.cValidatorAction({
+     *   register: {
+     *     profile: {
+     *       node_ip: { Ip: "1.2.3.4" },
+     *       name: "...",
+     *       description: "...",
+     *       delegations_disabled: true,
+     *       commission_bps: 1,
+     *       signer: "0x...",
+     *     },
+     *     unjailed: false,
+     *     initial_wei: 1,
+     *   },
+     * });
+     *
+     * // Unregister a validator
+     * await exchClient.cValidatorAction({ unregister: null });
+     * ```
+     */
+    async cValidatorAction(
+        params: DeepImmutable<CValidatorActionParameters>,
+        opts?: CValidatorActionOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(CValidatorActionRequest.entries.action)({
+            type: "CValidatorAction",
+            ...params,
+        });
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * Transfer native token from staking into the user's spot account.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#withdraw-from-staking
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.cWithdraw({ wei: 1 * 1e8 });
+     * ```
+     */
+    async cWithdraw(
+        params: DeepImmutable<CWithdrawParameters>,
+        opts?: CWithdrawOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(CWithdrawRequest.entries.action)({
+            type: "cWithdraw",
+            hyperliquidChain: this._getHyperliquidChain(),
+            signatureChainId: await this._getSignatureChainId(),
+            nonce: await this.nonceManager(),
+            ...params,
+        });
+        return await this._executeUserSignedAction({ action }, opts?.signal);
+    }
+
+    /**
+     * Configure block type for EVM transactions.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Response for creating a sub-account.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/hyperevm/dual-block-architecture
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * const data = await exchClient.evmUserModify({ usingBigBlocks: true });
+     * ```
+     */
+    async evmUserModify(
+        params: DeepImmutable<EvmUserModifyParameters>,
+        opts?: EvmUserModifyOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(EvmUserModifyRequest.entries.action)({
+            type: "evmUserModify",
+            ...params,
+        });
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * Modify an order.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#modify-an-order
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.modify({
+     *   oid: 123,
+     *   order: {
+     *     a: 0,
+     *     b: true,
+     *     p: "31000",
+     *     s: "0.2",
+     *     r: false,
+     *     t: { limit: { tif: "Gtc" } },
+     *     c: "0x...",
+     *   },
+     * });
+     * ```
+     */
+    async modify(
+        params: DeepImmutable<ModifyParameters>,
+        opts?: ModifyOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(ModifyRequest.entries.action)({
+            type: "modify",
+            ...params,
+        });
+        const vaultAddress = opts?.vaultAddress ?? this.defaultVaultAddress;
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, vaultAddress, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * A multi-signature request.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Any successful response.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/hypercore/multi-sig
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     * import { signL1Action } from "@nktkas/hyperliquid/signing";
+     * import { parser, ScheduleCancelRequest } from "@nktkas/hyperliquid/schemas";
+     * import { privateKeyToAccount } from "npm:viem/accounts";
+     *
+     * const wallet = privateKeyToAccount("0x..."); // or any other wallet libraries
+     * const multiSigUser = "0x...";
+     *
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet, transport });
+     *
+     * const nonce = Date.now();
+     * const action = parser(ScheduleCancelRequest.entries.action)({ // for correct signature generation
+     *   type: "scheduleCancel",
+     *   time: Date.now() + 10000,
+     * });
+     *
+     * // Create the required number of signatures
+     * const signatures = await Promise.all(["0x...", "0x..."].map(async (signerPrivKey) => {
+     *   return await signL1Action({
+     *     wallet: signerPrivKey as `0x${string}`,
+     *     action: [multiSigUser.toLowerCase(), wallet.address.toLowerCase(), action],
+     *     nonce,
+     *   });
+     * }));
+     *
+     * // // or user-signed action
+     * // const signatures = await Promise.all(["0x...", "0x..."].map(async (signerPrivKey) => {
+     * //   return await signUserSignedAction({
+     * //     wallet: signerPrivKey as `0x${string}`,
+     * //     action: {
+     * //       ...action,
+     * //       payloadMultiSigUser: multiSigUser,
+     * //       outerSigner: wallet.address,
+     * //     },
+     * //     types: userSignedActionEip712Types[action.type],
+     * //   });
+     * // }));
+     *
+     * // Then use signatures in the `multiSig` action
+     * const data = await exchClient.multiSig({
+     *   signatures,
+     *   payload: {
+     *     multiSigUser,
+     *     outerSigner: wallet.address,
+     *     action,
+     *   },
+     *   nonce,
+     * });
+     * ```
+     */
+    async multiSig<
+        T extends
+            | SuccessResponse
+            | CancelSuccessResponse
+            | CreateSubAccountResponse
+            | CreateVaultResponse
+            | OrderSuccessResponse
+            | TwapOrderSuccessResponse
+            | TwapCancelSuccessResponse,
+    >(
+        params_and_nonce: DeepImmutable<MultiSigParameters>,
+        opts?: MultiSigOptions,
+    ): Promise<T> {
+        const { nonce, ...params } = params_and_nonce;
+
+        const action = parser(MultiSigRequest.entries.action)({
+            type: "multiSig",
+            signatureChainId: await this._getSignatureChainId(),
+            ...params,
+        });
+        const vaultAddress = opts?.vaultAddress ?? this.defaultVaultAddress;
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeMultiSigAction({ action, vaultAddress, expiresAfter, nonce }, opts?.signal);
+    }
+
+    /**
+     * Place an order(s).
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful variant of {@link OrderResponse} without error statuses.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#place-an-order
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * const data = await exchClient.order({
+     *   orders: [
+     *     {
+     *       a: 0,
+     *       b: true,
+     *       p: "30000",
+     *       s: "0.1",
+     *       r: false,
+     *       t: { limit: { tif: "Gtc" } },
+     *       c: "0x...",
+     *     },
+     *   ],
+     *   grouping: "na",
+     * });
+     * ```
+     */
+    async order(
+        params: DeepImmutable<OrderParameters>,
+        opts?: OrderOptions,
+    ): Promise<OrderSuccessResponse> {
+        const action = parser(OrderRequest.entries.action)({
+            type: "order",
+            ...params,
+        });
+        const vaultAddress = opts?.vaultAddress ?? this.defaultVaultAddress;
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, vaultAddress, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * This action does not do anything (no operation), but causes the nonce to be marked as used.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#place-an-order
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.noop();
+     * ```
+     */
+    async noop(
+        opts?: NoopOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(NoopRequest.entries.action)({
+            type: "noop",
+        });
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * Deploying HIP-3 assets.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/deploying-hip-3-assets
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.perpDeploy({
+     *   registerAsset: {
+     *     maxGas: 1000000,
+     *     assetRequest: {
+     *       coin: "USDC",
+     *       szDecimals: 8,
+     *       oraclePx: "1",
+     *       marginTableId: 1,
+     *       onlyIsolated: false,
+     *     },
+     *     dex: "test",
+     *     schema: null,
+     *   },
+     * });
+     * ```
+     */
+    async perpDeploy(
+        params: DeepImmutable<PerpDeployParameters>,
+        opts?: PerpDeployOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(PerpDeployRequest.entries.action)({
+            type: "perpDeploy",
+            ...params,
+        });
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * Create a referral code.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.registerReferrer({ code: "..." });
+     * ```
+     */
+    async registerReferrer(
+        params: DeepImmutable<RegisterReferrerParameters>,
+        opts?: RegisterReferrerOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(RegisterReferrerRequest.entries.action)({
+            type: "registerReferrer",
+            ...params,
+        });
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * Reserve additional rate-limited actions for a fee.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#reserve-additional-actions
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.reserveRequestWeight({ weight: 10 });
+     * ```
+     */
+    async reserveRequestWeight(
+        params: DeepImmutable<ReserveRequestWeightParameters>,
+        opts?: ReserveRequestWeightOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(ReserveRequestWeightRequest.entries.action)({
+            type: "reserveRequestWeight",
+            ...params,
+        });
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * Schedule a cancel-all operation at a future time.
+     * @param params - An optional action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#schedule-cancel-dead-mans-switch
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.scheduleCancel({ time: Date.now() + 10_000 });
+     * ```
+     */
+    async scheduleCancel(
+        params?: DeepImmutable<ScheduleCancelParameters>,
+        opts?: ScheduleCancelOptions,
+    ): Promise<SuccessResponse>;
+    async scheduleCancel(opts?: ScheduleCancelOptions): Promise<SuccessResponse>;
+    async scheduleCancel(
+        params_or_opts?:
+            | DeepImmutable<ScheduleCancelParameters>
+            | ScheduleCancelOptions,
+        maybeOpts?: ScheduleCancelOptions,
+    ): Promise<SuccessResponse> {
+        const isFirstArgParams = params_or_opts && "time" in params_or_opts;
+        const params = isFirstArgParams ? params_or_opts : {};
+        const opts = isFirstArgParams ? maybeOpts : params_or_opts as ScheduleCancelOptions;
+
+        const action = parser(ScheduleCancelRequest.entries.action)({
+            type: "scheduleCancel",
+            ...params,
+        });
+        const vaultAddress = opts?.vaultAddress ?? this.defaultVaultAddress;
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, vaultAddress, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * Transfer tokens between different perp DEXs, spot balance, users, and/or sub-accounts.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#send-asset-testnet-only
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.sendAsset({
+     *   destination: "0x0000000000000000000000000000000000000001",
+     *   sourceDex: "",
+     *   destinationDex: "test",
+     *   token: "USDC:0xeb62eee3685fc4c43992febcd9e75443",
+     *   amount: "1",
+     *   fromSubAccount: "",
+     * });
+     * ```
+     */
+    async sendAsset(
+        params: DeepImmutable<SendAssetParameters>,
+        opts?: SendAssetOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(SendAssetRequest.entries.action)({
+            type: "sendAsset",
+            hyperliquidChain: this._getHyperliquidChain(),
+            signatureChainId: await this._getSignatureChainId(),
+            nonce: await this.nonceManager(),
+            ...params,
+        });
+        return await this._executeUserSignedAction({ action }, opts?.signal);
+    }
+
+    /**
+     * Set the display name in the leaderboard.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.setDisplayName({ displayName: "..." });
+     * ```
+     */
+    async setDisplayName(
+        params: DeepImmutable<SetDisplayNameParameters>,
+        opts?: SetDisplayNameOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(SetDisplayNameRequest.entries.action)({
+            type: "setDisplayName",
+            ...params,
+        });
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * Set a referral code.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.setReferrer({ code: "..." });
+     * ```
+     */
+    async setReferrer(
+        params: DeepImmutable<SetReferrerParameters>,
+        opts?: SetReferrerOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(SetReferrerRequest.entries.action)({
+            type: "setReferrer",
+            ...params,
+        });
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * Deploying HIP-1 and HIP-2 assets.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/deploying-hip-1-and-hip-2-assets
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.spotDeploy({
+     *   registerToken2: {
+     *     spec: {
+     *       name: "USDC",
+     *       szDecimals: 8,
+     *       weiDecimals: 8,
+     *     },
+     *     maxGas: 1000000,
+     *     fullName: "USD Coin",
+     *   },
+     * });
+     * ```
+     */
+    async spotDeploy(
+        params: DeepImmutable<SpotDeployParameters>,
+        opts?: SpotDeployOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(SpotDeployRequest.entries.action)({
+            type: "spotDeploy",
+            ...params,
+        });
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * Send spot assets to another address.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#core-spot-transfer
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.spotSend({
+     *   destination: "0x...",
+     *   token: "USDC:0xeb62eee3685fc4c43992febcd9e75443",
+     *   amount: "1",
+     * });
+     * ```
+     */
+    async spotSend(
+        params: DeepImmutable<SpotSendParameters>,
+        opts?: SpotSendOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(SpotSendRequest.entries.action)({
+            type: "spotSend",
+            hyperliquidChain: this._getHyperliquidChain(),
+            signatureChainId: await this._getSignatureChainId(),
+            time: await this.nonceManager(),
+            ...params,
+        });
+        return await this._executeUserSignedAction({ action }, opts?.signal);
+    }
+
+    /**
+     * Opt Out of Spot Dusting.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.spotUser({ toggleSpotDusting: { optOut: false } });
+     * ```
+     */
+    async spotUser(
+        params: DeepImmutable<SpotUserParameters>,
+        opts?: SpotUserOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(SpotUserRequest.entries.action)({
+            type: "spotUser",
+            ...params,
+        });
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * Modify a sub-account's.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.subAccountModify({ subAccountUser: "0x...", name: "..."  });
+     * ```
+     */
+    async subAccountModify(
+        params: DeepImmutable<SubAccountModifyParameters>,
+        opts?: SubAccountModifyOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(SubAccountModifyRequest.entries.action)({
+            type: "subAccountModify",
+            ...params,
+        });
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * Transfer between sub-accounts (spot).
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.subAccountSpotTransfer({
+     *   subAccountUser: "0x...",
+     *   isDeposit: true,
+     *   token: "USDC:0xeb62eee3685fc4c43992febcd9e75443",
+     *   amount: "1",
+     * });
+     * ```
+     */
+    async subAccountSpotTransfer(
+        params: DeepImmutable<SubAccountSpotTransferParameters>,
+        opts?: SubAccountSpotTransferOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(SubAccountSpotTransferRequest.entries.action)({
+            type: "subAccountSpotTransfer",
+            ...params,
+        });
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * Transfer between sub-accounts (perpetual).
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.subAccountTransfer({ subAccountUser: "0x...", isDeposit: true, usd: 1 * 1e6 });
+     * ```
+     */
+    async subAccountTransfer(
+        params: DeepImmutable<SubAccountTransferParameters>,
+        opts?: SubAccountTransferOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(SubAccountTransferRequest.entries.action)({
+            type: "subAccountTransfer",
+            ...params,
+        });
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * Delegate or undelegate native tokens to or from a validator.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#delegate-or-undelegate-stake-from-validator
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.tokenDelegate({ validator: "0x...", isUndelegate: true, wei: 1 * 1e8 });
+     * ```
+     */
+    async tokenDelegate(
+        params: DeepImmutable<TokenDelegateParameters>,
+        opts?: TokenDelegateOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(TokenDelegateRequest.entries.action)({
+            type: "tokenDelegate",
+            hyperliquidChain: this._getHyperliquidChain(),
+            signatureChainId: await this._getSignatureChainId(),
+            nonce: await this.nonceManager(),
+            ...params,
+        });
+        return await this._executeUserSignedAction({ action }, opts?.signal);
+    }
+
+    /**
+     * Cancel a TWAP order.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful variant of {@link TwapCancelResponse} without error status.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#cancel-a-twap-order
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * const data = await exchClient.twapCancel({ a: 0, t: 1 });
+     * ```
+     */
+    async twapCancel(
+        params: DeepImmutable<TwapCancelParameters>,
+        opts?: TwapCancelOptions,
+    ): Promise<TwapCancelSuccessResponse> {
+        const action = parser(TwapCancelRequest.entries.action)({
+            type: "twapCancel",
+            ...params,
+        });
+        const vaultAddress = opts?.vaultAddress ?? this.defaultVaultAddress;
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, vaultAddress, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * Place a TWAP order.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful variant of {@link TwapOrderResponse} without error status.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#place-a-twap-order
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * const data = await exchClient.twapOrder({
+     *   twap: {
+     *     a: 0,
+     *     b: true,
+     *     s: "1",
+     *     r: false,
+     *     m: 10,
+     *     t: true,
+     *   },
+     * });
+     * ```
+     */
+    async twapOrder(
+        params: DeepImmutable<TwapOrderParameters>,
+        opts?: TwapOrderOptions,
+    ): Promise<TwapOrderSuccessResponse> {
+        const action = parser(TwapOrderRequest.entries.action)({
+            type: "twapOrder",
+            ...params,
+        });
+        const vaultAddress = opts?.vaultAddress ?? this.defaultVaultAddress;
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, vaultAddress, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * Add or remove margin from isolated position.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#update-isolated-margin
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.updateIsolatedMargin({ asset: 0, isBuy: true, ntli: 1 * 1e6 });
+     * ```
+     */
+    async updateIsolatedMargin(
+        params: DeepImmutable<UpdateIsolatedMarginParameters>,
+        opts?: UpdateIsolatedMarginOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(UpdateIsolatedMarginRequest.entries.action)({
+            type: "updateIsolatedMargin",
+            ...params,
+        });
+        const vaultAddress = opts?.vaultAddress ?? this.defaultVaultAddress;
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, vaultAddress, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * Update cross or isolated leverage on a coin.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#update-leverage
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.updateLeverage({ asset: 0, isCross: true, leverage: 5 });
+     * ```
+     */
+    async updateLeverage(
+        params: DeepImmutable<UpdateLeverageParameters>,
+        opts?: UpdateLeverageOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(UpdateLeverageRequest.entries.action)({
+            type: "updateLeverage",
+            ...params,
+        });
+        const vaultAddress = opts?.vaultAddress ?? this.defaultVaultAddress;
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, vaultAddress, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * Transfer funds between Spot account and Perp account.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#transfer-from-spot-account-to-perp-account-and-vice-versa
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.usdClassTransfer({ amount: "1", toPerp: true });
+     * ```
+     */
+    async usdClassTransfer(
+        params: DeepImmutable<UsdClassTransferParameters>,
+        opts?: UsdClassTransferOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(UsdClassTransferRequest.entries.action)({
+            type: "usdClassTransfer",
+            hyperliquidChain: this._getHyperliquidChain(),
+            signatureChainId: await this._getSignatureChainId(),
+            nonce: await this.nonceManager(),
+            ...params,
+        });
+        return await this._executeUserSignedAction({ action }, opts?.signal);
+    }
+
+    /**
+     * Send usd to another address.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#core-usdc-transfer
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.usdSend({ destination: "0x...", amount: "1" });
+     * ```
+     */
+    async usdSend(
+        params: DeepImmutable<UsdSendParameters>,
+        opts?: UsdSendOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(UsdSendRequest.entries.action)({
+            type: "usdSend",
+            hyperliquidChain: this._getHyperliquidChain(),
+            signatureChainId: await this._getSignatureChainId(),
+            time: await this.nonceManager(),
+            ...params,
+        });
+        return await this._executeUserSignedAction({ action }, opts?.signal);
+    }
+
+    /**
+     * Distribute funds from a vault between followers.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.vaultDistribute({ vaultAddress: "0x...", usd: 10 * 1e6 });
+     * ```
+     */
+    async vaultDistribute(
+        params: DeepImmutable<VaultDistributeParameters>,
+        opts?: VaultDistributeOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(VaultDistributeRequest.entries.action)({
+            type: "vaultDistribute",
+            ...params,
+        });
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * Modify a vault's configuration.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.vaultModify({
+     *   vaultAddress: "0x...",
+     *   allowDeposits: true,
+     *   alwaysCloseOnWithdraw: false,
+     * });
+     * ```
+     */
+    async vaultModify(
+        params: DeepImmutable<VaultModifyParameters>,
+        opts?: VaultModifyOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(VaultModifyRequest.entries.action)({
+            type: "vaultModify",
+            ...params,
+        });
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * Deposit or withdraw from a vault.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#deposit-or-withdraw-from-a-vault
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.vaultTransfer({ vaultAddress: "0x...", isDeposit: true, usd: 10 * 1e6 });
+     * ```
+     */
+    async vaultTransfer(
+        params: DeepImmutable<VaultTransferParameters>,
+        opts?: VaultTransferOptions,
+    ): Promise<SuccessResponse> {
+        const action = parser(VaultTransferRequest.entries.action)({
+            type: "vaultTransfer",
+            ...params,
+        });
+        const expiresAfter = opts?.expiresAfter ?? await this._getDefaultExpiresAfter();
+        return await this._executeL1Action({ action, expiresAfter }, opts?.signal);
+    }
+
+    /**
+     * Initiate a withdrawal request.
+     * @param params - Action-specific parameters.
+     * @param opts - Request execution options.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#initiate-a-withdrawal-request
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.withdraw3({ destination: "0x...", amount: "1" });
+     * ```
+     */
+    async withdraw3(
+        params: DeepImmutable<Withdraw3Parameters>,
+        opts?: Withdraw3Options,
+    ): Promise<SuccessResponse> {
+        const action = parser(Withdraw3Request.entries.action)({
+            type: "withdraw3",
+            hyperliquidChain: this._getHyperliquidChain(),
+            signatureChainId: await this._getSignatureChainId(),
+            time: await this.nonceManager(),
+            ...params,
+        });
+        return await this._executeUserSignedAction({ action }, opts?.signal);
+    }
+
+    protected async _executeL1Action<
+        T extends
+            | SuccessResponse
+            | CancelSuccessResponse
+            | CreateSubAccountResponse
+            | CreateVaultResponse
+            | OrderSuccessResponse
+            | TwapOrderSuccessResponse
+            | TwapCancelSuccessResponse,
+    >(
+        request: {
+            action: Record<string, unknown>;
+            vaultAddress?: `0x${string}`;
+            expiresAfter: number | undefined;
+        },
+        signal?: AbortSignal,
+    ): Promise<T> {
+        const { action, vaultAddress, expiresAfter } = request;
+
+        // Sign an L1 action
+        const nonce = await this.nonceManager();
+        const signature = await signL1Action({
+            wallet: this.wallet,
+            action,
+            nonce,
+            isTestnet: this.transport.isTestnet,
+            vaultAddress,
+            expiresAfter,
+        });
+
+        // Send a request
+        const response = await this.transport.request(
+            "exchange",
+            { action, signature, nonce, vaultAddress, expiresAfter },
+            signal,
+        ) as
+            | SuccessResponse
+            | ErrorResponse
+            | CancelResponse
+            | CreateSubAccountResponse
+            | CreateVaultResponse
+            | OrderResponse
+            | TwapOrderResponse
+            | TwapCancelResponse;
+        this._validateResponse<T>(response);
+        return response;
+    }
+
+    protected async _executeUserSignedAction<
+        T extends
+            | SuccessResponse
+            | CancelSuccessResponse
+            | CreateSubAccountResponse
+            | CreateVaultResponse
+            | OrderSuccessResponse
+            | TwapOrderSuccessResponse
+            | TwapCancelSuccessResponse,
+    >(
+        request: {
+            action: {
+                type: keyof typeof userSignedActionEip712Types;
+                signatureChainId: `0x${string}`;
+                [key: string]: unknown;
+            };
+        },
+        signal?: AbortSignal,
+    ): Promise<T> {
+        const { action } = request;
+
+        // Sign a user-signed action
+        const nonce = "nonce" in action ? action.nonce : action.time;
+        const signature = await signUserSignedAction({
+            wallet: this.wallet,
+            action,
+            types: userSignedActionEip712Types[action.type],
+        });
+
+        // Send a request
+        const response = await this.transport.request(
+            "exchange",
+            { action, signature, nonce },
+            signal,
+        ) as
+            | SuccessResponse
+            | ErrorResponse
+            | CancelResponse
+            | CreateSubAccountResponse
+            | CreateVaultResponse
+            | OrderResponse
+            | TwapOrderResponse
+            | TwapCancelResponse;
+        this._validateResponse<T>(response);
+        return response;
+    }
+
+    protected async _executeMultiSigAction<
+        T extends
+            | SuccessResponse
+            | CancelSuccessResponse
+            | CreateSubAccountResponse
+            | CreateVaultResponse
+            | OrderSuccessResponse
+            | TwapOrderSuccessResponse
+            | TwapCancelSuccessResponse,
+    >(
+        request: {
+            action: {
+                signatureChainId: `0x${string}`;
+                [key: string]: unknown;
+            };
+            nonce: number;
+            vaultAddress?: `0x${string}`;
+            expiresAfter?: number;
+        },
+        signal?: AbortSignal,
+    ): Promise<T> {
+        const { action, nonce, vaultAddress, expiresAfter } = request;
+
+        // Sign a multi-signature action
+        const signature = await signMultiSigAction({
+            wallet: this.wallet,
+            action,
+            nonce,
+            isTestnet: this.transport.isTestnet,
+            vaultAddress,
+            expiresAfter,
+        });
+
+        // Send a request
+        const response = await this.transport.request(
+            "exchange",
+            { action, signature, nonce, vaultAddress, expiresAfter },
+            signal,
+        ) as
+            | SuccessResponse
+            | ErrorResponse
+            | CancelResponse
+            | CreateSubAccountResponse
+            | CreateVaultResponse
+            | OrderResponse
+            | TwapOrderResponse
+            | TwapCancelResponse;
+        this._validateResponse<T>(response);
+        return response;
+    }
+
+    protected async _getDefaultExpiresAfter(): Promise<number | undefined> {
+        return typeof this.defaultExpiresAfter === "number"
+            ? this.defaultExpiresAfter
+            : await this.defaultExpiresAfter?.();
+    }
+
+    protected async _getSignatureChainId(): Promise<`0x${string}`> {
+        return typeof this.signatureChainId === "string" ? this.signatureChainId : await this.signatureChainId();
+    }
+
+    protected _getHyperliquidChain(): "Mainnet" | "Testnet" {
+        return this.transport.isTestnet ? "Testnet" : "Mainnet";
+    }
+
+    protected _validateResponse<
+        T extends
+            | SuccessResponse
+            | CancelSuccessResponse
+            | CreateSubAccountResponse
+            | CreateVaultResponse
+            | OrderSuccessResponse
+            | TwapOrderSuccessResponse
+            | TwapCancelSuccessResponse,
+    >(
+        response:
+            | SuccessResponse
+            | ErrorResponse
+            | CancelResponse
+            | CreateSubAccountResponse
+            | CreateVaultResponse
+            | OrderResponse
+            | TwapOrderResponse
+            | TwapCancelResponse,
+    ): asserts response is T {
+        if (response.status === "err") {
+            throw new ApiRequestError(response as ErrorResponse);
+        } else if (response.response.type === "order" || response.response.type === "cancel") {
+            if (response.response.data.statuses.some((status) => typeof status === "object" && "error" in status)) {
+                throw new ApiRequestError(response as OrderResponse | CancelResponse);
+            }
+        } else if (response.response.type === "twapOrder" || response.response.type === "twapCancel") {
+            if (typeof response.response.data.status === "object" && "error" in response.response.data.status) {
+                throw new ApiRequestError(response as TwapOrderResponse | TwapCancelResponse);
+            }
+        }
+    }
+
+    async [Symbol.asyncDispose](): Promise<void> {
+        await this.transport[Symbol.asyncDispose]?.();
+    }
+}