@nktkas/hyperliquid 0.25.0-beta.4 → 0.25.0

package/esm/src/api/exchange/~client.d.ts

@@ -0,0 +1,1623 @@
+import type { OmitFirst, OverloadedParameters } from "../_common.js";
+import type { ExchangeRequestConfig, MaybePromise, MultiSignRequestConfig } from "./_common.js";
+import type { IRequestTransport } from "../../transport/base.js";
+import type { AbstractWallet } from "../../signing/mod.js";
+import { approveAgent } from "./approveAgent.js";
+import { approveBuilderFee } from "./approveBuilderFee.js";
+import { batchModify } from "./batchModify.js";
+import { cancel } from "./cancel.js";
+import { cancelByCloid } from "./cancelByCloid.js";
+import { cDeposit } from "./cDeposit.js";
+import { claimRewards } from "./claimRewards.js";
+import { convertToMultiSigUser } from "./convertToMultiSigUser.js";
+import { createSubAccount } from "./createSubAccount.js";
+import { createVault } from "./createVault.js";
+import { cSignerAction } from "./cSignerAction.js";
+import { cValidatorAction } from "./cValidatorAction.js";
+import { cWithdraw } from "./cWithdraw.js";
+import { evmUserModify } from "./evmUserModify.js";
+import { modify } from "./modify.js";
+import { multiSig } from "./multiSig.js";
+import { order } from "./order.js";
+import { noop } from "./noop.js";
+import { perpDeploy } from "./perpDeploy.js";
+import { registerReferrer } from "./registerReferrer.js";
+import { reserveRequestWeight } from "./reserveRequestWeight.js";
+import { scheduleCancel } from "./scheduleCancel.js";
+import { sendAsset } from "./sendAsset.js";
+import { setDisplayName } from "./setDisplayName.js";
+import { setReferrer } from "./setReferrer.js";
+import { spotDeploy } from "./spotDeploy.js";
+import { spotSend } from "./spotSend.js";
+import { spotUser } from "./spotUser.js";
+import { subAccountModify } from "./subAccountModify.js";
+import { subAccountSpotTransfer } from "./subAccountSpotTransfer.js";
+import { subAccountTransfer } from "./subAccountTransfer.js";
+import { tokenDelegate } from "./tokenDelegate.js";
+import { twapCancel } from "./twapCancel.js";
+import { twapOrder } from "./twapOrder.js";
+import { updateIsolatedMargin } from "./updateIsolatedMargin.js";
+import { updateLeverage } from "./updateLeverage.js";
+import { usdClassTransfer } from "./usdClassTransfer.js";
+import { usdSend } from "./usdSend.js";
+import { vaultDistribute } from "./vaultDistribute.js";
+import { vaultModify } from "./vaultModify.js";
+import { vaultTransfer } from "./vaultTransfer.js";
+import { withdraw3 } from "./withdraw3.js";
+export type { ApproveAgentParameters } from "./approveAgent.js";
+export type { ApproveBuilderFeeParameters } from "./approveBuilderFee.js";
+export type { BatchModifyParameters } from "./batchModify.js";
+export type { CancelParameters } from "./cancel.js";
+export type { CancelByCloidParameters } from "./cancelByCloid.js";
+export type { CDepositParameters } from "./cDeposit.js";
+export type { ConvertToMultiSigUserParameters } from "./convertToMultiSigUser.js";
+export type { CreateSubAccountParameters } from "./createSubAccount.js";
+export type { CreateVaultParameters } from "./createVault.js";
+export type { CSignerActionParameters } from "./cSignerAction.js";
+export type { CValidatorActionParameters } from "./cValidatorAction.js";
+export type { CWithdrawParameters } from "./cWithdraw.js";
+export type { EvmUserModifyParameters } from "./evmUserModify.js";
+export type { ModifyParameters } from "./modify.js";
+export type { MultiSigParameters } from "./multiSig.js";
+export type { OrderParameters } from "./order.js";
+export type { PerpDeployParameters } from "./perpDeploy.js";
+export type { RegisterReferrerParameters } from "./registerReferrer.js";
+export type { ReserveRequestWeightParameters } from "./reserveRequestWeight.js";
+export type { ScheduleCancelParameters } from "./scheduleCancel.js";
+export type { SendAssetParameters } from "./sendAsset.js";
+export type { SetDisplayNameParameters } from "./setDisplayName.js";
+export type { SetReferrerParameters } from "./setReferrer.js";
+export type { SpotDeployParameters } from "./spotDeploy.js";
+export type { SpotSendParameters } from "./spotSend.js";
+export type { SpotUserParameters } from "./spotUser.js";
+export type { SubAccountModifyParameters } from "./subAccountModify.js";
+export type { SubAccountSpotTransferParameters } from "./subAccountSpotTransfer.js";
+export type { SubAccountTransferParameters } from "./subAccountTransfer.js";
+export type { TokenDelegateParameters } from "./tokenDelegate.js";
+export type { TwapCancelParameters } from "./twapCancel.js";
+export type { TwapOrderParameters } from "./twapOrder.js";
+export type { UpdateIsolatedMarginParameters } from "./updateIsolatedMargin.js";
+export type { UpdateLeverageParameters } from "./updateLeverage.js";
+export type { UsdClassTransferParameters } from "./usdClassTransfer.js";
+export type { UsdSendParameters } from "./usdSend.js";
+export type { VaultDistributeParameters } from "./vaultDistribute.js";
+export type { VaultModifyParameters } from "./vaultModify.js";
+export type { VaultTransferParameters } from "./vaultTransfer.js";
+export type { Withdraw3Parameters } from "./withdraw3.js";
+export type { CancelSuccessResponse } from "./cancel.js";
+export type { CreateSubAccountResponse } from "./createSubAccount.js";
+export type { CreateVaultResponse } from "./createVault.js";
+export type { OrderSuccessResponse } from "./order.js";
+export type { TwapCancelSuccessResponse } from "./twapCancel.js";
+export type { TwapOrderSuccessResponse } from "./twapOrder.js";
+export type { ErrorResponse, SuccessResponse } from "./_common.js";
+export { ApiRequestError } from "./_common.js";
+/**
+ * A client for interacting with the Hyperliquid Exchange API.
+ * @typeParam T The transport (extends {@linkcode IRequestTransport}) used to connect to the Hyperliquid API.
+ * @typeParam W The wallet used for signing transactions.
+ */
+export declare class ExchangeClient<T extends IRequestTransport = IRequestTransport, W extends AbstractWallet = AbstractWallet> implements ExchangeRequestConfig<T, W> {
+    transport: T;
+    wallet: W;
+    signatureChainId?: string | (() => MaybePromise<string>);
+    nonceManager?: () => MaybePromise<number>;
+    defaultVaultAddress?: string;
+    defaultExpiresAfter?: number | (() => MaybePromise<number>);
+    /**
+     * Initialises a new instance.
+     * @param args - The parameters for the client.
+     *
+     * @example via a private key
+     * ```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 via [viem](https://viem.sh/docs/clients/wallet#local-accounts-private-key-mnemonic-etc)
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const pk = "0x...";
+     *
+     * const transport = new hl.HttpTransport();
+     * const exchClient = new hl.ExchangeClient({ wallet: pk, transport });
+     * ```
+     *
+     * @example via [ethers.js v6](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();
+     * const exchClient = new hl.ExchangeClient({ wallet, transport });
+     * ```
+     *
+     * @example via an external wallet (e.g. MetaMask) with [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();
+     * const exchClient = new hl.ExchangeClient({ wallet, transport });
+     * ```
+     */
+    constructor(args: Omit<ExchangeRequestConfig<T, W>, "wallet"> & (Pick<ExchangeRequestConfig<T, W>, "wallet"> | {
+        wallet: string;
+    }));
+    /**
+     * Approve an agent to sign on behalf of the master account.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.approveAgent({ agentAddress: "0x...", agentName: "..." });
+     * ```
+     */
+    approveAgent(...args: OmitFirst<OverloadedParameters<typeof approveAgent>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Approve a maximum fee rate for a builder.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.approveBuilderFee({ maxFeeRate: "0.01%", builder: "0x..." });
+     * ```
+     */
+    approveBuilderFee(...args: OmitFirst<OverloadedParameters<typeof approveBuilderFee>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Modify multiple orders.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * const data = await client.batchModify({
+     *   modifies: [
+     *     {
+     *       oid: 123,
+     *       order: {
+     *         a: 0,
+     *         b: true,
+     *         p: "31000",
+     *         s: "0.2",
+     *         r: false,
+     *         t: { limit: { tif: "Gtc" } },
+     *       },
+     *     },
+     *   ],
+     * });
+     * ```
+     */
+    batchModify(...args: OmitFirst<OverloadedParameters<typeof batchModify>>): Promise<{
+        status: "ok";
+        response: {
+            type: "order";
+            data: {
+                statuses: ({
+                    resting: {
+                        oid: number;
+                        cloid?: `0x${string}` | undefined;
+                    };
+                } | {
+                    filled: {
+                        totalSz: string;
+                        avgPx: string;
+                        oid: number;
+                        cloid?: `0x${string}` | undefined;
+                    };
+                })[];
+            };
+        };
+    }>;
+    /**
+     * Cancel order(s).
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * const data = await client.cancel({
+     *   cancels: [
+     *     { a: 0, o: 123 },
+     *   ],
+     * });
+     * ```
+     */
+    cancel(...args: OmitFirst<OverloadedParameters<typeof cancel>>): Promise<{
+        status: "ok";
+        response: {
+            type: "cancel";
+            data: {
+                statuses: "success"[];
+            };
+        };
+    }>;
+    /**
+     * Cancel order(s) by cloid.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * const data = await client.cancelByCloid({
+     *   cancels: [
+     *     { asset: 0, cloid: "0x..." },
+     *   ],
+     * });
+     * ```
+     */
+    cancelByCloid(...args: OmitFirst<OverloadedParameters<typeof cancelByCloid>>): Promise<{
+        status: "ok";
+        response: {
+            type: "cancel";
+            data: {
+                statuses: "success"[];
+            };
+        };
+    }>;
+    /**
+     * Transfer native token from the user spot account into staking for delegating to validators.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.cDeposit({ wei: 1 * 1e8 });
+     * ```
+     */
+    cDeposit(...args: OmitFirst<OverloadedParameters<typeof cDeposit>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * 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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.claimRewards();
+     * ```
+     */
+    claimRewards(...args: OmitFirst<OverloadedParameters<typeof claimRewards>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Convert a single-signature account to a multi-signature account or vice versa.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     *
+     * // Convert to multi-sig user
+     * await client.convertToMultiSigUser({
+     *   signers: {
+     *     authorizedUsers: ["0x...", "0x...", "0x..."],
+     *     threshold: 2,
+     *   },
+     * });
+     *
+     * // Convert to single-sig user
+     * await client.convertToMultiSigUser({ signers: null });
+     * ```
+     */
+    convertToMultiSigUser(...args: OmitFirst<OverloadedParameters<typeof convertToMultiSigUser>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Create a sub-account.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * const data = await client.createSubAccount({ name: "..." });
+     * ```
+     */
+    createSubAccount(...args: OmitFirst<OverloadedParameters<typeof createSubAccount>>): Promise<{
+        status: "ok";
+        response: {
+            type: "createSubAccount";
+            data: `0x${string}`;
+        };
+    }>;
+    /**
+     * Create a vault.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * const data = await client.createVault({
+     *   name: "...",
+     *   description: "...",
+     *   initialUsd: 100 * 1e6,
+     * });
+     * ```
+     */
+    createVault(...args: OmitFirst<OverloadedParameters<typeof createVault>>): Promise<{
+        status: "ok";
+        response: {
+            type: "createVault";
+            data: `0x${string}`;
+        };
+    }>;
+    /**
+     * Jail or unjail self as a validator signer.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     *
+     * // Jail self
+     * await client.cSignerAction({ jailSelf: null });
+     *
+     * // Unjail self
+     * await client.cSignerAction({ unjailSelf: null });
+     * ```
+     */
+    cSignerAction(...args: OmitFirst<OverloadedParameters<typeof cSignerAction>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Action related to validator management.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     *
+     * // Change validator profile
+     * await client.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 client.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 client.cValidatorAction({ unregister: null });
+     * ```
+     */
+    cValidatorAction(...args: OmitFirst<OverloadedParameters<typeof cValidatorAction>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Transfer native token from staking into the user's spot account.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.cWithdraw({ wei: 1 * 1e8 });
+     * ```
+     */
+    cWithdraw(...args: OmitFirst<OverloadedParameters<typeof cWithdraw>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Configure block type for EVM transactions.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.evmUserModify({ usingBigBlocks: true });
+     * ```
+     */
+    evmUserModify(...args: OmitFirst<OverloadedParameters<typeof evmUserModify>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Modify an order.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.modify({
+     *   oid: 123,
+     *   order: {
+     *     a: 0,
+     *     b: true,
+     *     p: "31000",
+     *     s: "0.2",
+     *     r: false,
+     *     t: { limit: { tif: "Gtc" } },
+     *     c: "0x...",
+     *   },
+     * });
+     * ```
+     */
+    modify(...args: OmitFirst<OverloadedParameters<typeof modify>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * A multi-signature request.
+     * @param params - Parameters specific to the API request.
+     * @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/api/exchange";
+     * import { privateKeyToAccount } from "npm:viem/accounts";
+     *
+     * const wallet = privateKeyToAccount("0x..."); // viem, ethers or private key
+     * const multiSigUser = "0x...";
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet });
+     * const nonce = Date.now();
+     * const action = parser(ScheduleCancelRequest.entries.action)({
+     *   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: privateKeyToAccount(signerPrivKey as `0x${string}`), // viem or ethers
+     *     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: privateKeyToAccount(signerPrivKey as `0x${string}`), // viem or ethers
+     * //     action: {
+     * //       ...action,
+     * //       payloadMultiSigUser: multiSigUser,
+     * //       outerSigner: wallet.address,
+     * //     },
+     * //     types: SomeTypes,
+     * //   });
+     * // }));
+     *
+     * // Then use signatures in the `multiSig` action
+     * const data = await client.multiSig({
+     *   signatures,
+     *   payload: {
+     *     multiSigUser,
+     *     outerSigner: wallet.address,
+     *     action,
+     *   },
+     *   nonce,
+     * });
+     * ```
+     */
+    multiSig(...args: OmitFirst<OverloadedParameters<typeof multiSig>>): Promise<{
+        status: "ok";
+        response: {
+            type: "order";
+            data: {
+                statuses: ({
+                    resting: {
+                        oid: number;
+                        cloid?: `0x${string}` | undefined;
+                    };
+                } | {
+                    filled: {
+                        totalSz: string;
+                        avgPx: string;
+                        oid: number;
+                        cloid?: `0x${string}` | undefined;
+                    };
+                })[];
+            };
+        };
+    } | {
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    } | {
+        status: "ok";
+        response: {
+            type: "cancel";
+            data: {
+                statuses: "success"[];
+            };
+        };
+    } | {
+        status: "ok";
+        response: {
+            type: "createSubAccount";
+            data: `0x${string}`;
+        };
+    } | {
+        status: "ok";
+        response: {
+            type: "createVault";
+            data: `0x${string}`;
+        };
+    } | {
+        status: "ok";
+        response: {
+            type: "twapOrder";
+            data: {
+                status: {
+                    running: {
+                        twapId: number;
+                    };
+                };
+            };
+        };
+    } | {
+        status: "ok";
+        response: {
+            type: "twapCancel";
+            data: {
+                status: string;
+            };
+        };
+    }>;
+    /**
+     * Place an order(s).
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * const data = await client.order({
+     *   orders: [
+     *     {
+     *       a: 0,
+     *       b: true,
+     *       p: "30000",
+     *       s: "0.1",
+     *       r: false,
+     *       t: { limit: { tif: "Gtc" } },
+     *       c: "0x...",
+     *     },
+     *   ],
+     *   grouping: "na",
+     * });
+     * ```
+     */
+    order(...args: OmitFirst<OverloadedParameters<typeof order>>): Promise<{
+        status: "ok";
+        response: {
+            type: "order";
+            data: {
+                statuses: ({
+                    resting: {
+                        oid: number;
+                        cloid?: `0x${string}` | undefined;
+                    };
+                } | {
+                    filled: {
+                        totalSz: string;
+                        avgPx: string;
+                        oid: number;
+                        cloid?: `0x${string}` | undefined;
+                    };
+                })[];
+            };
+        };
+    }>;
+    /**
+     * This action does not do anything (no operation), but causes the nonce to be marked as used.
+     * @param params - Parameters specific to the API request.
+     * @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#invalidate-pending-nonce-noop
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.noop();
+     * ```
+     */
+    noop(...args: OmitFirst<OverloadedParameters<typeof noop>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Deploying HIP-3 assets.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.perpDeploy({
+     *   registerAsset: {
+     *     maxGas: 1000000,
+     *     assetRequest: {
+     *       coin: "USDC",
+     *       szDecimals: 8,
+     *       oraclePx: "1",
+     *       marginTableId: 1,
+     *       onlyIsolated: false,
+     *     },
+     *     dex: "test",
+     *     schema: null,
+     *   },
+     * });
+     * ```
+     */
+    perpDeploy(...args: OmitFirst<OverloadedParameters<typeof perpDeploy>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Create a referral code.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.registerReferrer({ code: "..." });
+     * ```
+     */
+    registerReferrer(...args: OmitFirst<OverloadedParameters<typeof registerReferrer>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Reserve additional rate-limited actions for a fee.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.reserveRequestWeight({ weight: 10 });
+     * ```
+     */
+    reserveRequestWeight(...args: OmitFirst<OverloadedParameters<typeof reserveRequestWeight>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Schedule a cancel-all operation at a future time.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.scheduleCancel({ time: Date.now() + 10_000 });
+     * ```
+     */
+    scheduleCancel(...args: OmitFirst<OverloadedParameters<typeof scheduleCancel>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Transfer tokens between different perp DEXs, spot balance, users, and/or sub-accounts.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.sendAsset({
+     *   destination: "0x0000000000000000000000000000000000000001",
+     *   sourceDex: "",
+     *   destinationDex: "test",
+     *   token: "USDC:0xeb62eee3685fc4c43992febcd9e75443",
+     *   amount: "1",
+     * });
+     * ```
+     */
+    sendAsset(...args: OmitFirst<OverloadedParameters<typeof sendAsset>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Set the display name in the leaderboard.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.setDisplayName({ displayName: "..." });
+     * ```
+     */
+    setDisplayName(...args: OmitFirst<OverloadedParameters<typeof setDisplayName>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Set a referral code.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.setReferrer({ code: "..." });
+     * ```
+     */
+    setReferrer(...args: OmitFirst<OverloadedParameters<typeof setReferrer>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Deploying HIP-1 and HIP-2 assets.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.spotDeploy({
+     *   registerToken2: {
+     *     spec: {
+     *       name: "USDC",
+     *       szDecimals: 8,
+     *       weiDecimals: 8,
+     *     },
+     *     maxGas: 1000000,
+     *     fullName: "USD Coin",
+     *   },
+     * });
+     * ```
+     */
+    spotDeploy(...args: OmitFirst<OverloadedParameters<typeof spotDeploy>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Send spot assets to another address.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.spotSend({
+     *   destination: "0x...",
+     *   token: "USDC:0xeb62eee3685fc4c43992febcd9e75443",
+     *   amount: "1",
+     * });
+     * ```
+     */
+    spotSend(...args: OmitFirst<OverloadedParameters<typeof spotSend>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Opt Out of Spot Dusting.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.spotUser({ toggleSpotDusting: { optOut: false } });
+     * ```
+     */
+    spotUser(...args: OmitFirst<OverloadedParameters<typeof spotUser>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Modify a sub-account's.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.subAccountModify({ subAccountUser: "0x...", name: "..." });
+     * ```
+     */
+    subAccountModify(...args: OmitFirst<OverloadedParameters<typeof subAccountModify>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Transfer between sub-accounts (spot).
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.subAccountSpotTransfer({
+     *   subAccountUser: "0x...",
+     *   isDeposit: true,
+     *   token: "USDC:0xeb62eee3685fc4c43992febcd9e75443",
+     *   amount: "1",
+     * });
+     * ```
+     */
+    subAccountSpotTransfer(...args: OmitFirst<OverloadedParameters<typeof subAccountSpotTransfer>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Transfer between sub-accounts (perpetual).
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.subAccountTransfer({ subAccountUser: "0x...", isDeposit: true, usd: 1 * 1e6 });
+     * ```
+     */
+    subAccountTransfer(...args: OmitFirst<OverloadedParameters<typeof subAccountTransfer>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Delegate or undelegate native tokens to or from a validator.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.tokenDelegate({ validator: "0x...", isUndelegate: true, wei: 1 * 1e8 });
+     * ```
+     */
+    tokenDelegate(...args: OmitFirst<OverloadedParameters<typeof tokenDelegate>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Cancel a TWAP order.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * const data = await client.twapCancel({ a: 0, t: 1 });
+     * ```
+     */
+    twapCancel(...args: OmitFirst<OverloadedParameters<typeof twapCancel>>): Promise<{
+        status: "ok";
+        response: {
+            type: "twapCancel";
+            data: {
+                status: string;
+            };
+        };
+    }>;
+    /**
+     * Place a TWAP order.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * const data = await client.twapOrder({
+     *   twap: {
+     *     a: 0,
+     *     b: true,
+     *     s: "1",
+     *     r: false,
+     *     m: 10,
+     *     t: true,
+     *   },
+     * });
+     * ```
+     */
+    twapOrder(...args: OmitFirst<OverloadedParameters<typeof twapOrder>>): Promise<{
+        status: "ok";
+        response: {
+            type: "twapOrder";
+            data: {
+                status: {
+                    running: {
+                        twapId: number;
+                    };
+                };
+            };
+        };
+    }>;
+    /**
+     * Add or remove margin from isolated position.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.updateIsolatedMargin({ asset: 0, isBuy: true, ntli: 1 * 1e6 });
+     * ```
+     */
+    updateIsolatedMargin(...args: OmitFirst<OverloadedParameters<typeof updateIsolatedMargin>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Update cross or isolated leverage on a coin.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.updateLeverage({ asset: 0, isCross: true, leverage: 5 });
+     * ```
+     */
+    updateLeverage(...args: OmitFirst<OverloadedParameters<typeof updateLeverage>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Transfer funds between Spot account and Perp account.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.usdClassTransfer({ amount: "1", toPerp: true });
+     * ```
+     */
+    usdClassTransfer(...args: OmitFirst<OverloadedParameters<typeof usdClassTransfer>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Send usd to another address.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.usdSend({ destination: "0x...", amount: "1" });
+     * ```
+     */
+    usdSend(...args: OmitFirst<OverloadedParameters<typeof usdSend>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Distribute funds from a vault between followers.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.vaultDistribute({ vaultAddress: "0x...", usd: 10 * 1e6 });
+     * ```
+     */
+    vaultDistribute(...args: OmitFirst<OverloadedParameters<typeof vaultDistribute>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Modify a vault's configuration.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.vaultModify({
+     *   vaultAddress: "0x...",
+     *   allowDeposits: true,
+     *   alwaysCloseOnWithdraw: false,
+     * });
+     * ```
+     */
+    vaultModify(...args: OmitFirst<OverloadedParameters<typeof vaultModify>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Deposit or withdraw from a vault.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.vaultTransfer({ vaultAddress: "0x...", isDeposit: true, usd: 10 * 1e6 });
+     * ```
+     */
+    vaultTransfer(...args: OmitFirst<OverloadedParameters<typeof vaultTransfer>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Initiate a withdrawal request.
+     * @param params - Parameters specific to the API request.
+     * @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 pk = "0x..."; // viem, ethers or private key
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     *
+     * const client = new hl.ExchangeClient({ transport, wallet: pk });
+     * await client.withdraw3({ destination: "0x...", amount: "1" });
+     * ```
+     */
+    withdraw3(...args: OmitFirst<OverloadedParameters<typeof withdraw3>>): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+}
+/**
+ * A client for interacting with the Hyperliquid Exchange API using multi-signature wallet.
+ * Extends the {@link ExchangeClient} to support multi-signature operations.
+ * @typeParam T The transport (extends {@linkcode IRequestTransport}) used to connect to the Hyperliquid API.
+ * @typeParam S Array of wallets where the first wallet is the leader.
+ */
+export declare class MultiSignClient<T extends IRequestTransport = IRequestTransport, S extends readonly AbstractWallet[] = AbstractWallet[]> extends ExchangeClient<T, S[0]> implements MultiSignRequestConfig<T, S> {
+    multiSigUser: string;
+    signers: S;
+    /**
+     * @note Is the first wallet from {@linkcode signers}. Changing the property also changes the first element in the {@linkcode signers} array.
+     */
+    readonly wallet: S[0];
+    /**
+     * Initialises a new multi-signature client instance.
+     * @param args - The parameters for the multi-signature client.
+     *
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const multiSigUser = "0x...";
+     * const signers = [
+     *   "0x...", // viem, ethers or private key
+     *   // ... (more signers if needed)
+     * ] as const;
+     *
+     * const transport = new hl.HttpTransport();
+     * const multiSignClient = new hl.MultiSignClient({ transport, multiSigUser, signers });
+     * ```
+     */
+    constructor(args: Omit<MultiSignRequestConfig<T, S>, "signers"> & (Pick<MultiSignRequestConfig<T, S>, "signers"> | {
+        signers: readonly (S[number] | string)[];
+    }));
+}
+//# sourceMappingURL=~client.d.ts.map