@nktkas/hyperliquid 0.13.0

package/esm/src/clients/wallet.js

@@ -0,0 +1,984 @@
+import { sorters } from "../utils/key_sort.js";
+import { signL1Action, signUserSignedAction, } from "../utils/signing.js";
+// ———————————————Errors———————————————
+/** Error thrown when the API returns an error response. */
+export class ApiRequestError extends Error {
+    constructor(response) {
+        let message = "";
+        if (response.status === "err") {
+            message = response.response;
+        }
+        else {
+            if ("statuses" in response.response.data) {
+                message = response.response.data.statuses
+                    .reduce((acc, status, index) => {
+                    if (typeof status === "object" && "error" in status) {
+                        acc.push(`[${index}] ${status.error}`);
+                    }
+                    return acc;
+                }, [])
+                    .join(", ");
+            }
+            else {
+                if (typeof response.response.data.status === "object" && "error" in response.response.data.status) {
+                    message = response.response.data.status.error;
+                }
+            }
+        }
+        super(message);
+        Object.defineProperty(this, "response", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: response
+        });
+        this.name = "ApiRequestError";
+    }
+}
+// ———————————————Client———————————————
+/**
+ * Wallet client for interacting with the Hyperliquid API.
+ * @typeParam T - The transport used to connect to the Hyperliquid API.
+ * @typeParam W - The WalletClient/Account ([viem](https://viem.sh/docs/clients/wallet)) or Signer ([ethers.js](https://docs.ethers.io/v6/api/providers/#Signer)) used for signing transactions.
+ */
+export class WalletClient {
+    /**
+     * Initialises a new instance.
+     * @param args - The parameters for the client.
+     *
+     * @example Private key via [viem](https://viem.sh/docs/clients/wallet#local-accounts-private-key-mnemonic-etc)
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     * import { privateKeyToAccount } from "viem/accounts";
+     *
+     * const wallet = privateKeyToAccount("0x...");
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const client = new hl.WalletClient({ wallet, transport });
+     * ```
+     *
+     * @example Private key via [ethers.js](https://docs.ethers.org/v6/api/wallet/#Wallet)
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     * import { ethers } from "ethers";
+     *
+     * const wallet = new ethers.Wallet("0x...");
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const client = new hl.WalletClient({ wallet, transport });
+     * ```
+     *
+     * @example External wallet (e.g. MetaMask) via [viem](https://viem.sh/docs/clients/wallet#optional-hoist-the-account)
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     * import { createWalletClient, custom } from "viem";
+     * import { arbitrum } from "viem/chains";
+     *
+     * const [account] = await window.ethereum.request({ method: "eth_requestAccounts" });
+     * const wallet = createWalletClient({ account, chain: arbitrum, transport: custom(window.ethereum) });
+     *
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const client = new hl.WalletClient({ wallet, transport });
+     * ```
+     */
+    constructor(args) {
+        /** The transport used to connect to the Hyperliquid API. */
+        Object.defineProperty(this, "transport", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** The WalletClient/Account ([viem](https://viem.sh/docs/clients/wallet)) or Signer ([ethers.js](https://docs.ethers.org/v6/api/providers/#Signer)) used for signing transactions. */
+        Object.defineProperty(this, "wallet", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Specifies whether the client uses testnet. */
+        Object.defineProperty(this, "isTestnet", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Sets a default vaultAddress to be used if no vaultAddress is explicitly passed to a method. */
+        Object.defineProperty(this, "defaultVaultAddress", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.transport = args.transport;
+        this.wallet = args.wallet;
+        this.isTestnet = args.isTestnet ?? false;
+        this.defaultVaultAddress = args.defaultVaultAddress;
+    }
+    // ———————————————Actions———————————————
+    /**
+     * Approve an agent to sign on behalf of the master or sub-accounts.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal
+     * @returns {SuccessResponse} Successful response without specific data.
+     * @throws {ApiRequestError} When the API returns an error response.
+     *
+     * @see {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#approve-an-api-wallet | Hyperliquid GitBook}
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     * import { privateKeyToAccount } from "viem/accounts";
+     *
+     * const wallet = privateKeyToAccount("0x...");
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const client = new hl.WalletClient({ wallet, transport });
+     *
+     * const result = await client.approveAgent({
+     *   agentAddress: "0x...",
+     *   agentName: "agentName",
+     * });
+     */
+    async approveAgent(args, signal) {
+        const action = {
+            ...args,
+            type: "approveAgent",
+            hyperliquidChain: this.isTestnet ? "Testnet" : "Mainnet",
+            signatureChainId: args.signatureChainId ?? this.isTestnet ? "0x66eee" : "0xa4b1",
+            nonce: args.nonce ?? Date.now(),
+        };
+        const signature = await signUserSignedAction(this.wallet, action, {
+            "HyperliquidTransaction:ApproveAgent": [
+                { name: "hyperliquidChain", type: "string" },
+                { name: "agentAddress", type: "address" },
+                { name: "agentName", type: "string" },
+                { name: "nonce", type: "uint64" },
+            ],
+        }, parseInt(action.signatureChainId, 16));
+        const request = {
+            action,
+            signature,
+            nonce: action.nonce,
+        };
+        const response = await this.transport.request("action", request, signal);
+        this._validateResponse(response);
+        return response;
+    }
+    /**
+     * Approve a max fee rate for a builder address.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns {SuccessResponse} Successful response without specific data.
+     * @throws {ApiRequestError} When the API returns an error response.
+     *
+     * @see {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#approve-a-builder-fee | Hyperliquid GitBook}
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     * import { privateKeyToAccount } from "viem/accounts";
+     *
+     * const wallet = privateKeyToAccount("0x...");
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const client = new hl.WalletClient({ wallet, transport });
+     *
+     * const result = await client.approveBuilderFee({
+     *   maxFeeRate: "0.01%",
+     *   builder: "0x...",
+     * });
+     */
+    async approveBuilderFee(args, signal) {
+        const action = {
+            ...args,
+            type: "approveBuilderFee",
+            hyperliquidChain: this.isTestnet ? "Testnet" : "Mainnet",
+            signatureChainId: args.signatureChainId ?? this.isTestnet ? "0x66eee" : "0xa4b1",
+            nonce: args.nonce ?? Date.now(),
+        };
+        const signature = await signUserSignedAction(this.wallet, action, {
+            "HyperliquidTransaction:ApproveBuilderFee": [
+                { name: "hyperliquidChain", type: "string" },
+                { name: "maxFeeRate", type: "string" },
+                { name: "builder", type: "address" },
+                { name: "nonce", type: "uint64" },
+            ],
+        }, parseInt(action.signatureChainId, 16));
+        const request = {
+            action,
+            signature,
+            nonce: action.nonce,
+        };
+        const response = await this.transport.request("action", request, signal);
+        this._validateResponse(response);
+        return response;
+    }
+    /**
+     * Modify multiple orders.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns {OrderResponseSuccess} Successful variant of {@link OrderResponse} without error statuses.
+     * @throws {ApiRequestError} When the API returns an error response.
+     *
+     * @see {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#modify-multiple-orders | Hyperliquid GitBook}
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     * import { privateKeyToAccount } from "viem/accounts";
+     *
+     * const wallet = privateKeyToAccount("0x...");
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const client = new hl.WalletClient({ wallet, transport });
+     *
+     * const result = await client.batchModify({
+     *   modifies: [{
+     *     oid: 123, // Order ID
+     *     order: {
+     *       a: 0, // Asset index
+     *       b: true, // Buy order
+     *       p: "31000", // New price
+     *       s: "0.2", // New size
+     *       r: false, // Not reduce-only
+     *       t: {
+     *         limit: {
+     *           tif: "Gtc", // Good-til-cancelled
+     *         },
+     *       },
+     *       c: "0x...", // Optional: Client Order ID
+     *     },
+     *   }],
+     * });
+     * ```
+     */
+    async batchModify(args, signal) {
+        const { vaultAddress = this.defaultVaultAddress, nonce = Date.now(), ...actionArgs } = args;
+        const sortedAction = sorters.batchModify({ type: "batchModify", ...actionArgs });
+        const signature = await signL1Action(this.wallet, this.isTestnet, sortedAction, nonce, vaultAddress);
+        const request = {
+            action: sortedAction,
+            signature,
+            nonce,
+            vaultAddress,
+        };
+        const response = await this.transport.request("action", request, signal);
+        this._validateResponse(response);
+        return response;
+    }
+    /**
+     * Cancel order(s).
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns {CancelResponseSuccess} Successful variant of {@link CancelResponse} without error statuses.
+     * @throws {ApiRequestError} When the API returns an error response.
+     *
+     * @see {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#cancel-order-s | Hyperliquid GitBook}
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     * import { privateKeyToAccount } from "viem/accounts";
+     *
+     * const wallet = privateKeyToAccount("0x...");
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const client = new hl.WalletClient({ wallet, transport });
+     *
+     * const result = await client.cancel({
+     *   cancels: [{
+     *     a: 0, // Asset index
+     *     o: 123, // Order ID
+     *   }],
+     * });
+     * ```
+     */
+    async cancel(args, signal) {
+        const { vaultAddress = this.defaultVaultAddress, nonce = Date.now(), ...actionArgs } = args;
+        const sortedAction = sorters.cancel({ type: "cancel", ...actionArgs });
+        const signature = await signL1Action(this.wallet, this.isTestnet, sortedAction, nonce, vaultAddress);
+        const request = {
+            action: sortedAction,
+            signature,
+            nonce,
+            vaultAddress,
+        };
+        const response = await this.transport.request("action", request, signal);
+        this._validateResponse(response);
+        return response;
+    }
+    /**
+     * Cancel order(s) by Client Order ID.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns {CancelResponseSuccess} Successful variant of {@link CancelResponse} without error statuses.
+     * @throws {ApiRequestError} When the API returns an error response.
+     *
+     * @see {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#cancel-order-s-by-cloid | Hyperliquid GitBook}
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     * import { privateKeyToAccount } from "viem/accounts";
+     *
+     * const wallet = privateKeyToAccount("0x...");
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const client = new hl.WalletClient({ wallet, transport });
+     *
+     * const result = await client.cancelByCloid({
+     *   cancels: [{
+     *     asset: 0,
+     *     cloid: "0x...", // Client Order ID
+     *   }],
+     * });
+     * ```
+     */
+    async cancelByCloid(args, signal) {
+        const { vaultAddress = this.defaultVaultAddress, nonce = Date.now(), ...actionArgs } = args;
+        const sortedAction = sorters.cancelByCloid({ type: "cancelByCloid", ...actionArgs });
+        const signature = await signL1Action(this.wallet, this.isTestnet, sortedAction, nonce, vaultAddress);
+        const request = {
+            action: sortedAction,
+            signature,
+            nonce,
+            vaultAddress,
+        };
+        const response = await this.transport.request("action", request, signal);
+        this._validateResponse(response);
+        return response;
+    }
+    /**
+     * Create a sub-account.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns {CreateSubAccountResponse} Response for creating a sub-account.
+     * @throws {ApiRequestError} When the API returns an error response.
+     *
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     * import { privateKeyToAccount } from "viem/accounts";
+     *
+     * const wallet = privateKeyToAccount("0x...");
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const client = new hl.WalletClient({ wallet, transport });
+     *
+     * const result = await client.createSubAccount({
+     *   name: "subAccountName",
+     * });
+     * ```
+     */
+    async createSubAccount(args, signal) {
+        const { nonce = Date.now(), ...actionArgs } = args;
+        const sortedAction = sorters.createSubAccount({ type: "createSubAccount", ...actionArgs });
+        const signature = await signL1Action(this.wallet, this.isTestnet, sortedAction, nonce);
+        const request = {
+            action: sortedAction,
+            signature,
+            nonce,
+        };
+        const response = await this.transport.request("action", request, signal);
+        this._validateResponse(response);
+        return response;
+    }
+    /**
+     * Modify an order.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns {SuccessResponse} Successful response without specific data.
+     * @throws {ApiRequestError} When the API returns an error response.
+     *
+     * @see {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#modify-an-order | Hyperliquid GitBook}
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     * import { privateKeyToAccount } from "viem/accounts";
+     *
+     * const wallet = privateKeyToAccount("0x...");
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const client = new hl.WalletClient({ wallet, transport });
+     *
+     * const result = await client.modify({
+     *   oid: 123, // Order ID
+     *   order: {
+     *     a: 0, // Asset index
+     *     b: true, // Buy order
+     *     p: "31000", // New price
+     *     s: "0.2", // New size
+     *     r: false, // Not reduce-only
+     *     t: {
+     *       limit: {
+     *         tif: "Gtc", // Good-til-cancelled
+     *       },
+     *     },
+     *     c: "0x...", // Optional: Client Order ID
+     *   },
+     * });
+     * ```
+     */
+    async modify(args, signal) {
+        const { vaultAddress = this.defaultVaultAddress, nonce = Date.now(), ...actionArgs } = args;
+        const sortedAction = sorters.modify({ type: "modify", ...actionArgs });
+        const signature = await signL1Action(this.wallet, this.isTestnet, sortedAction, nonce, vaultAddress);
+        const request = {
+            action: sortedAction,
+            signature,
+            nonce,
+            vaultAddress,
+        };
+        const response = await this.transport.request("action", request, signal);
+        this._validateResponse(response);
+        return response;
+    }
+    /**
+     * Place an order(s).
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns {OrderResponseSuccess} Successful variant of {@link OrderResponse} without error statuses.
+     * @throws {ApiRequestError} When the API returns an error response.
+     *
+     * @see {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#place-an-order | Hyperliquid GitBook}
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     * import { privateKeyToAccount } from "viem/accounts";
+     *
+     * const wallet = privateKeyToAccount("0x...");
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const client = new hl.WalletClient({ wallet, transport });
+     *
+     * const result = await client.order({
+     *   orders: [{
+     *     a: 0, // Asset index
+     *     b: true, // Buy order
+     *     p: "30000", // Price
+     *     s: "0.1", // Size
+     *     r: false, // Not reduce-only
+     *     t: {
+     *       limit: {
+     *         tif: "Gtc", // Good-til-cancelled
+     *       },
+     *     },
+     *     c: "0x...", // Optional: Client Order ID
+     *   }],
+     *   grouping: "na", // No grouping
+     * });
+     * ```
+     */
+    async order(args, signal) {
+        const clonedArgs = structuredClone(args); // Clone to prevent mutation of original object
+        const { vaultAddress = this.defaultVaultAddress, nonce = Date.now(), ...actionArgs } = clonedArgs;
+        if (actionArgs.builder)
+            actionArgs.builder.b = actionArgs.builder.b.toLowerCase();
+        const sortedAction = sorters.order({ type: "order", ...actionArgs });
+        const signature = await signL1Action(this.wallet, this.isTestnet, sortedAction, nonce, vaultAddress);
+        const request = {
+            action: sortedAction,
+            signature,
+            nonce,
+            vaultAddress,
+        };
+        const response = await this.transport.request("action", request, signal);
+        this._validateResponse(response);
+        return response;
+    }
+    /**
+     * Schedule a time to cancel all open orders.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns {SuccessResponse} Successful response without specific data.
+     * @throws {ApiRequestError} When the API returns an error response.
+     *
+     * @see {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#schedule-cancel-dead-mans-switch | Hyperliquid GitBook}
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     * import { privateKeyToAccount } from "viem/accounts";
+     *
+     * const wallet = privateKeyToAccount("0x...");
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const client = new hl.WalletClient({ wallet, transport });
+     *
+     * const result = await client.scheduleCancel({
+     *   time: Date.now() + 3600000, // Schedule cancellation 1 hour from now
+     * });
+     * ```
+     */
+    async scheduleCancel(args = {}, signal) {
+        const { vaultAddress = this.defaultVaultAddress, nonce = Date.now(), ...actionArgs } = args;
+        const sortedAction = sorters.scheduleCancel({ type: "scheduleCancel", ...actionArgs });
+        const signature = await signL1Action(this.wallet, this.isTestnet, sortedAction, nonce, vaultAddress);
+        const request = {
+            action: sortedAction,
+            signature,
+            nonce,
+            vaultAddress,
+        };
+        const response = await this.transport.request("action", request, signal);
+        this._validateResponse(response);
+        return response;
+    }
+    /**
+     * Set a referral code.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns {SuccessResponse} Successful response without specific data.
+     * @throws {ApiRequestError} When the API returns an error response.
+     *
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     * import { privateKeyToAccount } from "viem/accounts";
+     *
+     * const wallet = privateKeyToAccount("0x...");
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const client = new hl.WalletClient({ wallet, transport });
+     *
+     * const result = await client.setReferrer({
+     *   code: "TEST",
+     * });
+     * ```
+     */
+    async setReferrer(args, signal) {
+        const { nonce = Date.now(), ...actionArgs } = args;
+        const sortedAction = sorters.setReferrer({ type: "setReferrer", ...actionArgs });
+        const signature = await signL1Action(this.wallet, this.isTestnet, sortedAction, nonce);
+        const request = {
+            action: sortedAction,
+            signature,
+            nonce,
+        };
+        const response = await this.transport.request("action", request, signal);
+        this._validateResponse(response);
+        return response;
+    }
+    /**
+     * Transfer a spot asset on L1 to another address.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns {SuccessResponse} Successful response without specific data.
+     * @throws {ApiRequestError} When the API returns an error response.
+     *
+     * @see {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#l1-spot-transfer | Hyperliquid GitBook}
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     * import { privateKeyToAccount } from "viem/accounts";
+     *
+     * const wallet = privateKeyToAccount("0x...");
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const client = new hl.WalletClient({ wallet, transport });
+     *
+     * const result = await client.spotSend({
+     *   destination: "0x...",
+     *   token: "USDC:0xeb62eee3685fc4c43992febcd9e75443",
+     *   amount: "1",
+     * });
+     * ```
+     */
+    async spotSend(args, signal) {
+        const action = {
+            ...args,
+            type: "spotSend",
+            hyperliquidChain: this.isTestnet ? "Testnet" : "Mainnet",
+            signatureChainId: args.signatureChainId ?? this.isTestnet ? "0x66eee" : "0xa4b1",
+            time: args.time ?? Date.now(),
+        };
+        const signature = await signUserSignedAction(this.wallet, action, {
+            "HyperliquidTransaction:SpotSend": [
+                { name: "hyperliquidChain", type: "string" },
+                { name: "destination", type: "string" },
+                { name: "token", type: "string" },
+                { name: "amount", type: "string" },
+                { name: "time", type: "uint64" },
+            ],
+        }, parseInt(action.signatureChainId, 16));
+        const request = {
+            action,
+            signature,
+            nonce: action.time,
+        };
+        const response = await this.transport.request("action", request, signal);
+        this._validateResponse(response);
+        return response;
+    }
+    /**
+     * Transfer between sub-accounts.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns {SuccessResponse} Successful response without specific data.
+     * @throws {ApiRequestError} When the API returns an error response.
+     *
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     * import { privateKeyToAccount } from "viem/accounts";
+     *
+     * const wallet = privateKeyToAccount("0x...");
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const client = new hl.WalletClient({ wallet, transport });
+     *
+     * const result = await client.subAccountTransfer({
+     *   subAccountUser: "0x...",
+     *   isDeposit: true,
+     *   usd: 1000000, // 1 USD in raw units (float amount * 1e6)
+     * });
+     * ```
+     */
+    async subAccountTransfer(args, signal) {
+        const { nonce = Date.now(), ...actionArgs } = args;
+        const sortedAction = sorters.subAccountTransfer({ type: "subAccountTransfer", ...actionArgs });
+        const signature = await signL1Action(this.wallet, this.isTestnet, sortedAction, nonce);
+        const request = {
+            action: sortedAction,
+            signature,
+            nonce,
+        };
+        const response = await this.transport.request("action", request, signal);
+        this._validateResponse(response);
+        return response;
+    }
+    /**
+     * Cancel a TWAP order.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns {TwapCancelResponseSuccess} Successful variant of {@link TwapCancelResponse} without error status.
+     * @throws {ApiRequestError} When the API returns an error response.
+     *
+     * @see {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#cancel-a-twap-order | Hyperliquid GitBook}
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     * import { privateKeyToAccount } from "viem/accounts";
+     *
+     * const wallet = privateKeyToAccount("0x...");
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const client = new hl.WalletClient({ wallet, transport });
+     *
+     * const result = await client.twapCancel({
+     *   a: 0, // Asset index
+     *   t: 1, // TWAP ID
+     * });
+     * ```
+     */
+    async twapCancel(args, signal) {
+        const { vaultAddress = this.defaultVaultAddress, nonce = Date.now(), ...actionArgs } = args;
+        const sortedAction = sorters.twapCancel({ type: "twapCancel", ...actionArgs });
+        const signature = await signL1Action(this.wallet, this.isTestnet, sortedAction, nonce, vaultAddress);
+        const request = {
+            action: sortedAction,
+            signature,
+            nonce,
+            vaultAddress,
+        };
+        const response = await this.transport.request("action", request, signal);
+        this._validateResponse(response);
+        return response;
+    }
+    /**
+     * Place a TWAP order.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns {TwapOrderResponseSuccess} Successful variant of {@link TwapOrderResponse} without error status.
+     * @throws {ApiRequestError} When the API returns an error response.
+     *
+     * @see {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#place-a-twap-order | Hyperliquid GitBook}
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     * import { privateKeyToAccount } from "viem/accounts";
+     *
+     * const wallet = privateKeyToAccount("0x...");
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const client = new hl.WalletClient({ wallet, transport });
+     *
+     * const result = await client.twapOrder({
+     *   a: 0, // Asset index
+     *   b: true, // Buy order
+     *   s: "1", // Size
+     *   r: false, // Not reduce-only
+     *   m: 10, // Duration in minutes
+     *   t: true, // Randomize order timing
+     * });
+     * ```
+     */
+    async twapOrder(args, signal) {
+        const { vaultAddress = this.defaultVaultAddress, nonce = Date.now(), ...actionArgs } = args;
+        const sortedAction = sorters.twapOrder({ type: "twapOrder", twap: actionArgs });
+        const signature = await signL1Action(this.wallet, this.isTestnet, sortedAction, nonce, vaultAddress);
+        const request = {
+            action: sortedAction,
+            signature,
+            nonce,
+            vaultAddress,
+        };
+        const response = await this.transport.request("action", request, signal);
+        this._validateResponse(response);
+        return response;
+    }
+    /**
+     * Update isolated margin for a position.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns {SuccessResponse} Successful response without specific data.
+     * @throws {ApiRequestError} When the API returns an error response.
+     *
+     * @see {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#update-isolated-margin | Hyperliquid GitBook}
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     * import { privateKeyToAccount } from "viem/accounts";
+     *
+     * const wallet = privateKeyToAccount("0x...");
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const client = new hl.WalletClient({ wallet, transport });
+     *
+     * const result = await client.updateIsolatedMargin({
+     *   asset: 0,
+     *   isBuy: true, // Add to long position
+     *   ntli: 1000, // Add 1000 USD margin (integer only)
+     * });
+     * ```
+     */
+    async updateIsolatedMargin(args, signal) {
+        const { vaultAddress = this.defaultVaultAddress, nonce = Date.now(), ...actionArgs } = args;
+        const sortedAction = sorters.updateIsolatedMargin({ type: "updateIsolatedMargin", ...actionArgs });
+        const signature = await signL1Action(this.wallet, this.isTestnet, sortedAction, nonce, vaultAddress);
+        const request = {
+            action: sortedAction,
+            signature,
+            nonce,
+            vaultAddress,
+        };
+        const response = await this.transport.request("action", request, signal);
+        this._validateResponse(response);
+        return response;
+    }
+    /**
+     * Update leverage for cross or isolated margin.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns {SuccessResponse} Successful response without specific data.
+     * @throws {ApiRequestError} When the API returns an error response.
+     *
+     * @see {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#update-leverage | Hyperliquid GitBook}
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     * import { privateKeyToAccount } from "viem/accounts";
+     *
+     * const wallet = privateKeyToAccount("0x...");
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const client = new hl.WalletClient({ wallet, transport });
+     *
+     * const result = await client.updateLeverage({
+     *   asset: 0,
+     *   isCross: true,
+     *   leverage: 5,
+     * });
+     * ```
+     */
+    async updateLeverage(args, signal) {
+        const { vaultAddress = this.defaultVaultAddress, nonce = Date.now(), ...actionArgs } = args;
+        const sortedAction = sorters.updateLeverage({ type: "updateLeverage", ...actionArgs });
+        const signature = await signL1Action(this.wallet, this.isTestnet, sortedAction, nonce, vaultAddress);
+        const request = {
+            action: sortedAction,
+            signature,
+            nonce,
+            vaultAddress,
+        };
+        const response = await this.transport.request("action", request, signal);
+        this._validateResponse(response);
+        return response;
+    }
+    /**
+     * Transfer funds between Spot and Perp accounts.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns {SuccessResponse} Successful response without specific data.
+     * @throws {ApiRequestError} When the API returns an error response.
+     *
+     * @see {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#transfer-from-spot-account-to-perp-account-and-vice-versa | Hyperliquid GitBook}
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     * import { privateKeyToAccount } from "viem/accounts";
+     *
+     * const wallet = privateKeyToAccount("0x...");
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const client = new hl.WalletClient({ wallet, transport });
+     *
+     * const result = await client.usdClassTransfer({
+     *   amount: "1000",
+     *   toPerp: true, // Transfer from Spot to Perp
+     * });
+     * ```
+     */
+    async usdClassTransfer(args, signal) {
+        const action = {
+            ...args,
+            type: "usdClassTransfer",
+            hyperliquidChain: this.isTestnet ? "Testnet" : "Mainnet",
+            signatureChainId: args.signatureChainId ?? this.isTestnet ? "0x66eee" : "0xa4b1",
+            nonce: args.nonce ?? Date.now(),
+        };
+        const signature = await signUserSignedAction(this.wallet, action, {
+            "HyperliquidTransaction:UsdClassTransfer": [
+                { name: "hyperliquidChain", type: "string" },
+                { name: "amount", type: "string" },
+                { name: "toPerp", type: "bool" },
+                { name: "nonce", type: "uint64" },
+            ],
+        }, parseInt(action.signatureChainId, 16));
+        const request = {
+            action,
+            signature,
+            nonce: action.nonce,
+        };
+        const response = await this.transport.request("action", request, signal);
+        this._validateResponse(response);
+        return response;
+    }
+    /**
+     * Transfer USDC on L1 to another address.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns {SuccessResponse} Successful response without specific data.
+     * @throws {ApiRequestError} When the API returns an error response.
+     *
+     * @see {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#l1-usdc-transfer | Hyperliquid GitBook}
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     * import { privateKeyToAccount } from "viem/accounts";
+     *
+     * const wallet = privateKeyToAccount("0x...");
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const client = new hl.WalletClient({ wallet, transport });
+     *
+     * const result = await client.usdSend({
+     *   destination: "0x...",
+     *   amount: "1000",
+     * });
+     * ```
+     */
+    async usdSend(args, signal) {
+        const action = {
+            ...args,
+            type: "usdSend",
+            hyperliquidChain: this.isTestnet ? "Testnet" : "Mainnet",
+            signatureChainId: args.signatureChainId ?? this.isTestnet ? "0x66eee" : "0xa4b1",
+            time: args.time ?? Date.now(),
+        };
+        const signature = await signUserSignedAction(this.wallet, action, {
+            "HyperliquidTransaction:UsdSend": [
+                { name: "hyperliquidChain", type: "string" },
+                { name: "destination", type: "string" },
+                { name: "amount", type: "string" },
+                { name: "time", type: "uint64" },
+            ],
+        }, parseInt(action.signatureChainId, 16));
+        const request = {
+            action,
+            signature,
+            nonce: action.time,
+        };
+        const response = await this.transport.request("action", request, signal);
+        this._validateResponse(response);
+        return response;
+    }
+    /**
+     * Transfer funds to/from a vault.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns {SuccessResponse} Successful response without specific data.
+     * @throws {ApiRequestError} When the API returns an error response.
+     *
+     * @see {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#deposit-or-withdraw-from-a-vault | Hyperliquid GitBook}
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     * import { privateKeyToAccount } from "viem/accounts";
+     *
+     * const wallet = privateKeyToAccount("0x...");
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const client = new hl.WalletClient({ wallet, transport });
+     *
+     * const result = await client.vaultTransfer({
+     *   vaultAddress: "0x...",
+     *   isDeposit: true,
+     *   usd: 1000000, // 1 USD in raw units (float amount * 1e6)
+     * });
+     * ```
+     */
+    async vaultTransfer(args, signal) {
+        const { nonce = Date.now(), ...actionArgs } = args;
+        const sortedAction = sorters.vaultTransfer({ type: "vaultTransfer", ...actionArgs });
+        const signature = await signL1Action(this.wallet, this.isTestnet, sortedAction, nonce);
+        const request = {
+            action: sortedAction,
+            signature,
+            nonce,
+        };
+        const response = await this.transport.request("action", request, signal);
+        this._validateResponse(response);
+        return response;
+    }
+    /**
+     * Initiate a withdrawal request.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns {SuccessResponse} Successful response without specific data.
+     * @throws {ApiRequestError} When the API returns an error response.
+     *
+     * @see {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#initiate-a-withdrawal-request | Hyperliquid GitBook}
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     * import { privateKeyToAccount } from "viem/accounts";
+     *
+     * const wallet = privateKeyToAccount("0x...");
+     * const transport = new hl.HttpTransport(); // or WebSocketTransport
+     * const client = new hl.WalletClient({ wallet, transport });
+     *
+     * const result = await client.withdraw3({
+     *   destination: "0x...",
+     *   amount: "1000",
+     * });
+     * ```
+     */
+    async withdraw3(args, signal) {
+        const action = {
+            ...args,
+            type: "withdraw3",
+            hyperliquidChain: this.isTestnet ? "Testnet" : "Mainnet",
+            signatureChainId: args.signatureChainId ?? this.isTestnet ? "0x66eee" : "0xa4b1",
+            time: args.time ?? Date.now(),
+        };
+        const signature = await signUserSignedAction(this.wallet, action, {
+            "HyperliquidTransaction:Withdraw": [
+                { name: "hyperliquidChain", type: "string" },
+                { name: "destination", type: "string" },
+                { name: "amount", type: "string" },
+                { name: "time", type: "uint64" },
+            ],
+        }, parseInt(action.signatureChainId, 16));
+        const request = {
+            action,
+            signature,
+            nonce: action.time,
+        };
+        const response = await this.transport.request("action", request, signal);
+        this._validateResponse(response);
+        return response;
+    }
+    /** Validate a response from the API. */
+    _validateResponse(response) {
+        if (response.status === "err") {
+            throw new ApiRequestError(response);
+        }
+        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);
+            }
+        }
+        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);
+            }
+        }
+    }
+}