@nktkas/hyperliquid 0.22.2 → 0.23.1

package/esm/src/clients/exchange.js

@@ -70,7 +70,7 @@ export class ExchangeClient {
      * Initialises a new instance.
      * @param args - The parameters for the client.
      *
-     * @example Private key
+     * @example Private key directly
      * ```ts
      * import * as hl from "@nktkas/hyperliquid";
      *
@@ -80,18 +80,18 @@ export class ExchangeClient {
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      * ```
      *
-     * @example Private key via [viem](https://viem.sh/docs/clients/wallet#local-accounts-private-key-mnemonic-etc)
+     * @example [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 account = privateKeyToAccount("0x...");
      *
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
-     * const exchClient = new hl.ExchangeClient({ wallet, transport });
+     * const exchClient = new hl.ExchangeClient({ wallet: account, transport });
      * ```
      *
-     * @example Private key via [ethers.js](https://docs.ethers.org/v6/api/wallet/#Wallet) or [ethers.js v5](https://docs.ethers.org/v5/api/signer/#Wallet)
+     * @example [ethers.js](https://docs.ethers.org/v6/api/wallet/#Wallet) or [ethers.js v5](https://docs.ethers.org/v5/api/signer/#Wallet)
      * ```ts
      * import * as hl from "@nktkas/hyperliquid";
      * import { ethers } from "ethers";
@@ -102,24 +102,26 @@ export class ExchangeClient {
      * const exchClient = new hl.ExchangeClient({ wallet, transport });
      * ```
      *
-     * @example External wallet (e.g. MetaMask) via [viem](https://viem.sh/docs/clients/wallet#optional-hoist-the-account)
+     * @example External wallet (e.g. MetaMask) via [viem](https://viem.sh/docs/clients/wallet)
      * ```ts
      * import * as hl from "@nktkas/hyperliquid";
      * import { createWalletClient, custom } from "viem";
      *
-     * const [account] = await window.ethereum.request({ method: "eth_requestAccounts" });
-     * const wallet = createWalletClient({ account, transport: custom(window.ethereum) });
+     * const ethereum = (window as any).ethereum;
+     * const [account] = await ethereum.request({ method: "eth_requestAccounts" });
+     * const wallet = createWalletClient({ account, transport: custom(ethereum) });
      *
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet, transport });
      * ```
      *
-     * @example External wallet (e.g. MetaMask) via `window.ethereum` directly
+     * @example External wallet (e.g. MetaMask) via [`window.ethereum`](https://eips.ethereum.org/EIPS/eip-1193)
      * ```ts
      * import * as hl from "@nktkas/hyperliquid";
      *
+     * const ethereum = (window as any).ethereum;
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
-     * const exchClient = new hl.ExchangeClient({ wallet: window.ethereum, transport });
+     * const exchClient = new hl.ExchangeClient({ wallet: ethereum, transport });
      * ```
      */
     constructor(args) {
@@ -136,7 +138,9 @@ export class ExchangeClient {
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal
      * @returns Successful response without specific data.
-     * @throws {ApiRequestError} When the API returns an error 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/for-developers/api/exchange-endpoint#approve-an-api-wallet
      * @example
@@ -147,7 +151,7 @@ export class ExchangeClient {
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
-     * const data = await exchClient.approveAgent({ agentAddress: "0x...", agentName: "agentName" });
+     * await exchClient.approveAgent({ agentAddress: "0x...", agentName: "..." });
      * ```
      */
     async approveAgent(args, signal) {
@@ -155,32 +159,34 @@ export class ExchangeClient {
         const { ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            ...actionArgs,
-            agentName: args.agentName ?? "",
+        const action = actionSorter.approveAgent({
             type: "approveAgent",
             hyperliquidChain: this._getHyperliquidChain(),
             signatureChainId: await this._getSignatureChainId(),
             nonce,
-        };
+            ...actionArgs,
+        });
         // Sign the action
         const signature = await signUserSignedAction({
             wallet: this.wallet,
             action,
             types: userSignedActionEip712Types[action.type],
-            chainId: parseInt(action.signatureChainId, 16),
         });
         if (action.agentName === "")
             action.agentName = null;
         // Send a request
-        return await this._request({ action, signature, nonce }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Approve a maximum fee rate for a builder.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful response without specific data.
-     * @throws {ApiRequestError} When the API returns an error 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/for-developers/api/exchange-endpoint#approve-a-builder-fee
      * @example
@@ -191,7 +197,7 @@ export class ExchangeClient {
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
-     * const data = await exchClient.approveBuilderFee({ maxFeeRate: "0.01%", builder: "0x..." });
+     * await exchClient.approveBuilderFee({ maxFeeRate: "0.01%", builder: "0x..." });
      * ```
      */
     async approveBuilderFee(args, signal) {
@@ -199,29 +205,32 @@ export class ExchangeClient {
         const { ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            ...actionArgs,
+        const action = actionSorter.approveBuilderFee({
             type: "approveBuilderFee",
             hyperliquidChain: this._getHyperliquidChain(),
             signatureChainId: await this._getSignatureChainId(),
             nonce,
-        };
+            ...actionArgs,
+        });
         // Sign the action
         const signature = await signUserSignedAction({
             wallet: this.wallet,
             action,
             types: userSignedActionEip712Types[action.type],
-            chainId: parseInt(action.signatureChainId, 16),
         });
         // Send a request
-        return await this._request({ action, signature, nonce }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Modify multiple orders.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful variant of {@link OrderResponse} without error statuses.
-     * @throws {ApiRequestError} When the API returns an error 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/for-developers/api/exchange-endpoint#modify-multiple-orders
      * @example
@@ -233,22 +242,19 @@ export class ExchangeClient {
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
      * const data = await exchClient.batchModify({
-     *   modifies: [{
-     *     oid: 123,
-     *     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
-     *         },
+     *   modifies: [
+     *     {
+     *       oid: 123,
+     *       order: {
+     *         a: 0,
+     *         b: true,
+     *         p: "31000",
+     *         s: "0.2",
+     *         r: false,
+     *         t: { limit: { tif: "Gtc" } },
      *       },
-     *       c: "0x...", // Client Order ID (optional)
      *     },
-     *   }],
+     *   ],
      * });
      * ```
      */
@@ -257,28 +263,29 @@ export class ExchangeClient {
         const { vaultAddress = this.defaultVaultAddress, expiresAfter = await this._getDefaultExpiresAfter(), ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            type: "batchModify",
-            ...actionArgs,
-        };
+        const action = actionSorter.batchModify({ type: "batchModify", ...actionArgs });
         // Sign the action
         const signature = await signL1Action({
             wallet: this.wallet,
-            action: actionSorter[action.type](action),
+            action,
             nonce,
             isTestnet: this.isTestnet,
             vaultAddress,
             expiresAfter,
         });
         // Send a request
-        return await this._request({ action, signature, nonce, vaultAddress, expiresAfter }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce, vaultAddress, expiresAfter }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Cancel order(s).
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful variant of {@link CancelResponse} without error statuses.
-     * @throws {ApiRequestError} When the API returns an error 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/for-developers/api/exchange-endpoint#cancel-order-s
      * @example
@@ -290,10 +297,9 @@ export class ExchangeClient {
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
      * const data = await exchClient.cancel({
-     *   cancels: [{
-     *     a: 0, // Asset index
-     *     o: 123, // Order ID
-     *   }],
+     *   cancels: [
+     *     { a: 0, o: 123 },
+     *   ],
      * });
      * ```
      */
@@ -302,28 +308,29 @@ export class ExchangeClient {
         const { vaultAddress = this.defaultVaultAddress, expiresAfter = await this._getDefaultExpiresAfter(), ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            type: "cancel",
-            ...actionArgs,
-        };
+        const action = actionSorter.cancel({ type: "cancel", ...actionArgs });
         // Sign the action
         const signature = await signL1Action({
             wallet: this.wallet,
-            action: actionSorter[action.type](action),
+            action,
             nonce,
             isTestnet: this.isTestnet,
             vaultAddress,
             expiresAfter,
         });
         // Send a request
-        return await this._request({ action, signature, nonce, vaultAddress, expiresAfter }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce, vaultAddress, expiresAfter }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Cancel order(s) by cloid.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful variant of {@link CancelResponse} without error statuses.
-     * @throws {ApiRequestError} When the API returns an error 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/for-developers/api/exchange-endpoint#cancel-order-s-by-cloid
      * @example
@@ -346,28 +353,29 @@ export class ExchangeClient {
         const { vaultAddress = this.defaultVaultAddress, expiresAfter = await this._getDefaultExpiresAfter(), ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            type: "cancelByCloid",
-            ...actionArgs,
-        };
+        const action = actionSorter.cancelByCloid({ type: "cancelByCloid", ...actionArgs });
         // Sign the action
         const signature = await signL1Action({
             wallet: this.wallet,
-            action: actionSorter[action.type](action),
+            action,
             nonce,
             isTestnet: this.isTestnet,
             vaultAddress,
             expiresAfter,
         });
         // Send a request
-        return await this._request({ action, signature, nonce, vaultAddress, expiresAfter }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce, vaultAddress, expiresAfter }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Transfer native token from the user's spot account into staking for delegating to validators.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful response without specific data.
-     * @throws {ApiRequestError} When the API returns an error 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/for-developers/api/exchange-endpoint#deposit-into-staking
      * @example
@@ -378,7 +386,7 @@ export class ExchangeClient {
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
-     * const data = await exchClient.cDeposit({ wei: 1 * 1e8 });
+     * await exchClient.cDeposit({ wei: 1 * 1e8 });
      * ```
      */
     async cDeposit(args, signal) {
@@ -386,31 +394,34 @@ export class ExchangeClient {
         const { ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            ...actionArgs,
+        const action = actionSorter.cDeposit({
             type: "cDeposit",
             hyperliquidChain: this._getHyperliquidChain(),
             signatureChainId: await this._getSignatureChainId(),
             nonce,
-        };
+            ...actionArgs,
+        });
         // Sign the action
         const signature = await signUserSignedAction({
             wallet: this.wallet,
             action,
             types: userSignedActionEip712Types[action.type],
-            chainId: parseInt(action.signatureChainId, 16),
         });
         // Send a request
-        return await this._request({ action, signature, nonce }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Claim rewards from referral program.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful response without specific data.
-     * @throws {ApiRequestError} When the API returns an error response.
      *
-     * @see null - no documentation
+     * @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";
@@ -419,31 +430,33 @@ export class ExchangeClient {
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
-     * const data = await exchClient.claimRewards();
+     * await exchClient.claimRewards();
      * ```
      */
     async claimRewards(signal) {
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            type: "claimRewards",
-        };
+        const action = actionSorter.claimRewards({ type: "claimRewards" });
         // Sign the action
         const signature = await signL1Action({
             wallet: this.wallet,
-            action: actionSorter[action.type](action),
+            action,
             nonce,
             isTestnet: this.isTestnet,
         });
         // Send a request
-        return await this._request({ action, signature, nonce }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Convert a single-signature account to a multi-signature account or vice versa.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful response without specific data.
-     * @throws {ApiRequestError} When the API returns an error 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
@@ -454,10 +467,14 @@ export class ExchangeClient {
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
-     * const data = await exchClient.convertToMultiSigUser({ // convert to multi-sig user
+     * // Convert to multi-sig user
+     * await exchClient.convertToMultiSigUser({
      *   authorizedUsers: ["0x...", "0x...", "0x..."],
      *   threshold: 2,
      * });
+     *
+     * // Convert to single-sig user
+     * await exchClient.convertToMultiSigUser(null);
      * ```
      */
     async convertToMultiSigUser(args, signal) {
@@ -465,31 +482,34 @@ export class ExchangeClient {
         const actionArgs = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
+        const action = actionSorter.convertToMultiSigUser({
             type: "convertToMultiSigUser",
             hyperliquidChain: this._getHyperliquidChain(),
             signatureChainId: await this._getSignatureChainId(),
             signers: JSON.stringify(actionArgs),
             nonce,
-        };
+        });
         // Sign the action
         const signature = await signUserSignedAction({
             wallet: this.wallet,
             action,
             types: userSignedActionEip712Types[action.type],
-            chainId: parseInt(action.signatureChainId, 16),
         });
         // Send a request
-        return await this._request({ action, signature, nonce }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Create a sub-account.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Response for creating a sub-account.
-     * @throws {ApiRequestError} When the API returns an error response.
      *
-     * @see null - no documentation
+     * @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";
@@ -498,7 +518,7 @@ export class ExchangeClient {
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
-     * const data = await exchClient.createSubAccount({ name: "subAccountName" });
+     * const data = await exchClient.createSubAccount({ name: "..." });
      * ```
      */
     async createSubAccount(args, signal) {
@@ -506,28 +526,29 @@ export class ExchangeClient {
         const { ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            type: "createSubAccount",
-            ...actionArgs,
-        };
+        const action = actionSorter.createSubAccount({ type: "createSubAccount", ...actionArgs });
         // Sign the action
         const signature = await signL1Action({
             wallet: this.wallet,
-            action: actionSorter[action.type](action),
+            action,
             nonce,
             isTestnet: this.isTestnet,
         });
         // Send a request
-        return await this._request({ action, signature, nonce }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Create a vault.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Response for creating a vault.
-     * @throws {ApiRequestError} When the API returns an error response.
      *
-     * @see null - no documentation
+     * @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";
@@ -536,11 +557,7 @@ export class ExchangeClient {
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
-     * const data = await exchClient.createVault({
-     *   name: "VaultName",
-     *   description: "Vault description",
-     *   initialUsd: 100 * 1e6,
-     * });
+     * const data = await exchClient.createVault({ name: "...", description: "...", initialUsd: 100 * 1e6 });
      * ```
      */
     async createVault(args, signal) {
@@ -548,67 +565,137 @@ export class ExchangeClient {
         const { ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            type: "createVault",
-            nonce,
-            ...actionArgs,
-        };
+        const action = actionSorter.createVault({ type: "createVault", nonce, ...actionArgs });
         // Sign the action
         const signature = await signL1Action({
             wallet: this.wallet,
-            action: actionSorter[action.type](action),
+            action,
             nonce,
             isTestnet: this.isTestnet,
         });
         // Send a request
-        return await this._request({ action, signature, nonce }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce }, signal);
+        this._validateResponse(response);
+        return response;
     }
+    /**
+     * Jail or unjail self as a validator signer.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // or `viem`, `ethers`
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * // Jail self
+     * await exchClient.cSignerAction({ jailSelf: null });
+     *
+     * // Unjail self
+     * await exchClient.cSignerAction({ unjailSelf: null });
+     * ```
+     */
     async cSignerAction(args, signal) {
         // Destructure the parameters
         const { expiresAfter = await this._getDefaultExpiresAfter(), ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            type: "CSignerAction",
-            ...actionArgs,
-        };
+        const action = actionSorter.CSignerAction({ type: "CSignerAction", ...actionArgs });
         // Sign the action
         const signature = await signL1Action({
             wallet: this.wallet,
-            action: actionSorter[action.type](action),
+            action,
             nonce,
             isTestnet: this.isTestnet,
             expiresAfter,
         });
         // Send a request
-        return await this._request({ action, signature, nonce, expiresAfter }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce, expiresAfter }, signal);
+        this._validateResponse(response);
+        return response;
     }
+    /**
+     * Action related to validator management.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see null
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // or `viem`, `ethers`
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * // Change validator profile
+     * await exchClient.cValidatorAction({
+     *   changeProfile: {
+     *     name: "...",
+     *     description: "...",
+     *     unjailed: true,
+     *   }
+     * });
+     *
+     * // Register a new validator
+     * await exchClient.cValidatorAction({
+     *   register: {
+     *     profile: {
+     *       node_ip: { Ip: "1.2.3.4" },
+     *       name: "...",
+     *       description: "...",
+     *       delegations_disabled: true,
+     *       commission_bps: 1,
+     *       signer: "0x...",
+     *     },
+     *     unjailed: false,
+     *     initial_wei: 1,
+     *   },
+     * });
+     *
+     * // Unregister a validator
+     * await exchClient.cValidatorAction({ unregister: null });
+     * ```
+     */
     async cValidatorAction(args, signal) {
         // Destructure the parameters
         const { expiresAfter = await this._getDefaultExpiresAfter(), ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            type: "CValidatorAction",
-            ...actionArgs,
-        };
+        const action = actionSorter.CValidatorAction({ type: "CValidatorAction", ...actionArgs });
         // Sign the action
         const signature = await signL1Action({
             wallet: this.wallet,
-            action: actionSorter[action.type](action),
+            action,
             nonce,
             isTestnet: this.isTestnet,
             expiresAfter,
         });
         // Send a request
-        return await this._request({ action, signature, nonce, expiresAfter }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce, expiresAfter }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Transfer native token from staking into the user's spot account.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful response without specific data.
-     * @throws {ApiRequestError} When the API returns an error 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/for-developers/api/exchange-endpoint#withdraw-from-staking
      * @example
@@ -619,7 +706,7 @@ export class ExchangeClient {
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
-     * const data = await exchClient.cWithdraw({ wei: 1 * 1e8 });
+     * await exchClient.cWithdraw({ wei: 1 * 1e8 });
      * ```
      */
     async cWithdraw(args, signal) {
@@ -627,29 +714,32 @@ export class ExchangeClient {
         const { ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            ...actionArgs,
+        const action = actionSorter.cWithdraw({
             type: "cWithdraw",
             hyperliquidChain: this._getHyperliquidChain(),
             signatureChainId: await this._getSignatureChainId(),
             nonce,
-        };
+            ...actionArgs,
+        });
         // Sign the action
         const signature = await signUserSignedAction({
             wallet: this.wallet,
             action,
             types: userSignedActionEip712Types[action.type],
-            chainId: parseInt(action.signatureChainId, 16),
         });
         // Send a request
-        return await this._request({ action, signature, nonce }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Configure block type for EVM transactions.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Response for creating a sub-account.
-     * @throws {ApiRequestError} When the API returns an error 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/for-developers/evm/dual-block-architecture
      * @example
@@ -668,26 +758,27 @@ export class ExchangeClient {
         const { ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            type: "evmUserModify",
-            ...actionArgs,
-        };
+        const action = actionSorter.evmUserModify({ type: "evmUserModify", ...actionArgs });
         // Sign the action
         const signature = await signL1Action({
             wallet: this.wallet,
-            action: actionSorter[action.type](action),
+            action,
             nonce,
             isTestnet: this.isTestnet,
         });
         // Send a request
-        return await this._request({ action, signature, nonce }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Modify an order.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful response without specific data.
-     * @throws {ApiRequestError} When the API returns an error 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/for-developers/api/exchange-endpoint#modify-an-order
      * @example
@@ -698,20 +789,16 @@ export class ExchangeClient {
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
-     * const data = await exchClient.modify({
+     * await exchClient.modify({
      *   oid: 123,
      *   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...", // Client Order ID (optional)
+     *     a: 0,
+     *     b: true,
+     *     p: "31000",
+     *     s: "0.2",
+     *     r: false,
+     *     t: { limit: { tif: "Gtc" } },
+     *     c: "0x...",
      *   },
      * });
      * ```
@@ -721,48 +808,54 @@ export class ExchangeClient {
         const { vaultAddress = this.defaultVaultAddress, expiresAfter = await this._getDefaultExpiresAfter(), ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            type: "modify",
-            ...actionArgs,
-        };
+        const action = actionSorter.modify({ type: "modify", ...actionArgs });
         // Sign the action
         const signature = await signL1Action({
             wallet: this.wallet,
-            action: actionSorter[action.type](action),
+            action,
             nonce,
             isTestnet: this.isTestnet,
             vaultAddress,
             expiresAfter,
         });
         // Send a request
-        return await this._request({ action, signature, nonce, vaultAddress, expiresAfter }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce, vaultAddress, expiresAfter }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * A multi-signature request.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
-     * @returns Successful response without specific data.
-     * @throws {ApiRequestError} When the API returns an error response.
+     * @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 { actionSorter, signL1Action } from "@nktkas/hyperliquid/signing";
+     * import { privateKeyToAccount } from "viem/accounts";
      *
-     * const privateKey = "0x..."; // or `viem`, `ethers`
-     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
-     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     * const wallet = privateKeyToAccount("0x..."); // or any other wallet libraries
+     * const multiSigUser = "0x...";
      *
-     * const multiSigUser = "0x..."; // Multi-sig user address
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet, transport });
      *
      * const nonce = Date.now();
-     * const action = { type: "scheduleCancel", time: Date.now() + 10000 };
+     * const action = {
+     *   type: "scheduleCancel",
+     *   time: Date.now() + 10000,
+     * } as const;
      *
-     * const signature = await hl.signL1Action({
+     * // Create the required number of signatures
+     * const signature = await signL1Action({
      *   wallet,
-     *   action: [multiSigUser.toLowerCase(), signer1.address.toLowerCase(), action],
+     *   action: [multiSigUser.toLowerCase(), wallet.address.toLowerCase(), actionSorter[action.type](action)],
      *   nonce,
-     *   isTestnet: true,
      * });
      *
      * const data = await exchClient.multiSig({
@@ -780,32 +873,36 @@ export class ExchangeClient {
         // Destructure the parameters
         const { vaultAddress = this.defaultVaultAddress, expiresAfter = await this._getDefaultExpiresAfter(), nonce, ...actionArgs } = args;
         // Construct an action
-        const action = {
+        const action = actionSorter.multiSig({
             type: "multiSig",
             signatureChainId: await this._getSignatureChainId(),
             ...actionArgs,
-        };
+        });
         // Sign the action
-        const actionForMultiSig = actionSorter[action.type](action);
-        delete actionForMultiSig.type;
+        // deno-lint-ignore no-explicit-any
+        const actionWithoutType = structuredClone(action);
+        delete actionWithoutType.type;
         const signature = await signMultiSigAction({
             wallet: this.wallet,
-            action: actionForMultiSig,
+            action: actionWithoutType,
             nonce,
+            isTestnet: this.isTestnet,
             vaultAddress,
             expiresAfter,
-            hyperliquidChain: this._getHyperliquidChain(),
-            signatureChainId: action.signatureChainId,
         });
         // Send a request
-        return await this._request({ action, signature, nonce, vaultAddress, expiresAfter }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce, vaultAddress, expiresAfter }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Place an order(s).
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful variant of {@link OrderResponse} without error statuses.
-     * @throws {ApiRequestError} When the API returns an error 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/for-developers/api/exchange-endpoint#place-an-order
      * @example
@@ -817,20 +914,18 @@ export class ExchangeClient {
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
      * const data = await exchClient.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
-     *       },
+     *   orders: [
+     *     {
+     *       a: 0,
+     *       b: true,
+     *       p: "30000",
+     *       s: "0.1",
+     *       r: false,
+     *       t: { limit: { tif: "Gtc" } },
+     *       c: "0x...",
      *     },
-     *     c: "0x...", // Client Order ID (optional)
-     *   }],
-     *   grouping: "na", // No grouping
+     *   ],
+     *   grouping: "na",
      * });
      * ```
      */
@@ -839,47 +934,80 @@ export class ExchangeClient {
         const { vaultAddress = this.defaultVaultAddress, expiresAfter = await this._getDefaultExpiresAfter(), ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            type: "order",
-            ...actionArgs,
-        };
+        const action = actionSorter.order({ type: "order", ...actionArgs });
         // Sign the action
         const signature = await signL1Action({
             wallet: this.wallet,
-            action: actionSorter[action.type](action),
+            action,
             nonce,
             isTestnet: this.isTestnet,
             vaultAddress,
             expiresAfter,
         });
         // Send a request
-        return await this._request({ action, signature, nonce, vaultAddress, expiresAfter }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce, vaultAddress, expiresAfter }, signal);
+        this._validateResponse(response);
+        return response;
     }
+    /**
+     * Deploying HIP-3 assets.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/deploying-hip-3-assets
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // or `viem`, `ethers`
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.perpDeploy({
+     *   registerAsset: {
+     *     maxGas: 1000000,
+     *     assetRequest: {
+     *       coin: "USDC",
+     *       szDecimals: 8,
+     *       oraclePx: "1",
+     *       marginTableId: 1,
+     *       onlyIsolated: false,
+     *     },
+     *     dex: "test",
+     *   },
+     * });
+     * ```
+     */
     async perpDeploy(args, signal) {
         // Destructure the parameters
         const { ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            type: "perpDeploy",
-            ...actionArgs,
-        };
+        const action = actionSorter.perpDeploy({ type: "perpDeploy", ...actionArgs });
         // Sign the action
         const signature = await signL1Action({
             wallet: this.wallet,
-            action: actionSorter[action.type](action),
+            action,
             nonce,
             isTestnet: this.isTestnet,
         });
         // Send a request
-        return await this._request({ action, signature, nonce }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Transfer funds between Spot account and Perp dex account.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful response without specific data.
-     * @throws {ApiRequestError} When the API returns an error 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/for-developers/api/exchange-endpoint#transfer-from-spot-account-to-perp-account-and-vice-versa
      * @example
@@ -890,12 +1018,7 @@ export class ExchangeClient {
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
-     * const data = await exchClient.perpDexClassTransfer({
-     *   dex: "test",
-     *   token: "USDC",
-     *   amount: "1",
-     *   toPerp: true,
-     * });
+     * await exchClient.perpDexClassTransfer({ dex: "test", token: "USDC", amount: "1", toPerp: true });
      * ```
      */
     async perpDexClassTransfer(args, signal) {
@@ -903,31 +1026,78 @@ export class ExchangeClient {
         const { ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            ...actionArgs,
+        const action = actionSorter.PerpDexClassTransfer({
             type: "PerpDexClassTransfer",
             hyperliquidChain: this._getHyperliquidChain(),
             signatureChainId: await this._getSignatureChainId(),
             nonce,
-        };
+            ...actionArgs,
+        });
+        // Sign the action
+        const signature = await signUserSignedAction({
+            wallet: this.wallet,
+            action,
+            types: userSignedActionEip712Types[action.type],
+        });
+        // Send a request
+        const response = await this.transport.request("exchange", { action, signature, nonce }, signal);
+        this._validateResponse(response);
+        return response;
+    }
+    /**
+     * Transfer collateral tokens between different perp dexes for the same user.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @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-perp-account-to-perp-account-for-builder-deployed-dex
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // or `viem`, `ethers`
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.perpDexTransfer({ sourceDex: "", destinationDex: "test", amount: "1" });
+     * ```
+     */
+    async perpDexTransfer(args, signal) {
+        // Destructure the parameters
+        const { ...actionArgs } = args;
+        // Construct an action
+        const nonce = await this.nonceManager();
+        const action = actionSorter.PerpDexTransfer({
+            type: "PerpDexTransfer",
+            hyperliquidChain: this._getHyperliquidChain(),
+            signatureChainId: await this._getSignatureChainId(),
+            nonce,
+            ...actionArgs,
+        });
         // Sign the action
         const signature = await signUserSignedAction({
             wallet: this.wallet,
             action,
             types: userSignedActionEip712Types[action.type],
-            chainId: parseInt(action.signatureChainId, 16),
         });
         // Send a request
-        return await this._request({ action, signature, nonce }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Create a referral code.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful response without specific data.
-     * @throws {ApiRequestError} When the API returns an error response.
      *
-     * @see null - no documentation
+     * @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";
@@ -936,7 +1106,7 @@ export class ExchangeClient {
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
-     * const data = await exchClient.registerReferrer({ code: "TEST" });
+     * await exchClient.registerReferrer({ code: "..." });
      * ```
      */
     async registerReferrer(args, signal) {
@@ -944,26 +1114,27 @@ export class ExchangeClient {
         const { ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            type: "registerReferrer",
-            ...actionArgs,
-        };
+        const action = actionSorter.registerReferrer({ type: "registerReferrer", ...actionArgs });
         // Sign the action
         const signature = await signL1Action({
             wallet: this.wallet,
-            action: actionSorter[action.type](action),
+            action,
             nonce,
             isTestnet: this.isTestnet,
         });
         // Send a request
-        return await this._request({ action, signature, nonce }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Reserve additional rate-limited actions for a fee.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful response without specific data.
-     * @throws {ApiRequestError} When the API returns an error 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/for-developers/api/exchange-endpoint#reserve-additional-actions
      * @example
@@ -974,7 +1145,7 @@ export class ExchangeClient {
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
-     * const data = await exchClient.reserveRequestWeight({ weight: 10 });
+     * await exchClient.reserveRequestWeight({ weight: 10 });
      * ```
      */
     async reserveRequestWeight(args, signal) {
@@ -982,20 +1153,19 @@ export class ExchangeClient {
         const { expiresAfter = await this._getDefaultExpiresAfter(), ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            type: "reserveRequestWeight",
-            ...actionArgs,
-        };
+        const action = actionSorter.reserveRequestWeight({ type: "reserveRequestWeight", ...actionArgs });
         // Sign the action
         const signature = await signL1Action({
             wallet: this.wallet,
-            action: actionSorter[action.type](action),
+            action,
             nonce,
             isTestnet: this.isTestnet,
             expiresAfter,
         });
         // Send a request
-        return await this._request({ action, signature, nonce, expiresAfter }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce, expiresAfter }, signal);
+        this._validateResponse(response);
+        return response;
     }
     async scheduleCancel(args_or_signal, maybeSignal) {
         const args = args_or_signal instanceof AbortSignal ? {} : args_or_signal ?? {};
@@ -1004,30 +1174,31 @@ export class ExchangeClient {
         const { vaultAddress = this.defaultVaultAddress, expiresAfter = await this._getDefaultExpiresAfter(), ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            type: "scheduleCancel",
-            ...actionArgs,
-        };
+        const action = actionSorter.scheduleCancel({ type: "scheduleCancel", ...actionArgs });
         // Sign the action
         const signature = await signL1Action({
             wallet: this.wallet,
-            action: actionSorter[action.type](action),
+            action,
             nonce,
             isTestnet: this.isTestnet,
             vaultAddress,
             expiresAfter,
         });
         // Send a request
-        return await this._request({ action, signature, nonce, vaultAddress, expiresAfter }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce, vaultAddress, expiresAfter }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Set the display name in the leaderboard.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful response without specific data.
-     * @throws {ApiRequestError} When the API returns an error response.
      *
-     * @see null - no documentation
+     * @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";
@@ -1036,7 +1207,7 @@ export class ExchangeClient {
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
-     * const data = await exchClient.setDisplayName({ displayName: "My Name" });
+     * await exchClient.setDisplayName({ displayName: "..." });
      * ```
      */
     async setDisplayName(args, signal) {
@@ -1044,28 +1215,29 @@ export class ExchangeClient {
         const { ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            type: "setDisplayName",
-            ...actionArgs,
-        };
+        const action = actionSorter.setDisplayName({ type: "setDisplayName", ...actionArgs });
         // Sign the action
         const signature = await signL1Action({
             wallet: this.wallet,
-            action: actionSorter[action.type](action),
+            action,
             nonce,
             isTestnet: this.isTestnet,
         });
         // Send a request
-        return await this._request({ action, signature, nonce }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Set a referral code.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful response without specific data.
-     * @throws {ApiRequestError} When the API returns an error response.
      *
-     * @see null - no documentation
+     * @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";
@@ -1074,7 +1246,7 @@ export class ExchangeClient {
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
-     * const data = await exchClient.setReferrer({ code: "TEST" });
+     * await exchClient.setReferrer({ code: "..." });
      * ```
      */
     async setReferrer(args, signal) {
@@ -1082,45 +1254,76 @@ export class ExchangeClient {
         const { ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            type: "setReferrer",
-            ...actionArgs,
-        };
+        const action = actionSorter.setReferrer({ type: "setReferrer", ...actionArgs });
         // Sign the action
         const signature = await signL1Action({
             wallet: this.wallet,
-            action: actionSorter[action.type](action),
+            action,
             nonce,
             isTestnet: this.isTestnet,
         });
         // Send a request
-        return await this._request({ action, signature, nonce }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce }, signal);
+        this._validateResponse(response);
+        return response;
     }
+    /**
+     * Deploying HIP-1 and HIP-2 assets.
+     * @param args - The parameters for the request.
+     * @param signal - An optional abort signal.
+     * @returns Successful response without specific data.
+     *
+     * @throws {ApiRequestError} When the API returns an unsuccessful response.
+     * @throws {TransportError} When the transport layer throws an error.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/deploying-hip-1-and-hip-2-assets
+     * @example
+     * ```ts
+     * import * as hl from "@nktkas/hyperliquid";
+     *
+     * const privateKey = "0x..."; // or `viem`, `ethers`
+     * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+     * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
+     *
+     * await exchClient.spotDeploy({
+     *   registerToken2: {
+     *     spec: {
+     *       name: "USDC",
+     *       szDecimals: 8,
+     *       weiDecimals: 8,
+     *     },
+     *     maxGas: 1000000,
+     *     fullName: "USD Coin",
+     *   },
+     * });
+     * ```
+     */
     async spotDeploy(args, signal) {
         // Destructure the parameters
         const { ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            type: "spotDeploy",
-            ...actionArgs,
-        };
+        const action = actionSorter.spotDeploy({ type: "spotDeploy", ...actionArgs });
         // Sign the action
         const signature = await signL1Action({
             wallet: this.wallet,
-            action: actionSorter[action.type](action),
+            action,
             nonce,
             isTestnet: this.isTestnet,
         });
         // Send a request
-        return await this._request({ action, signature, nonce }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Send spot assets to another address.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful response without specific data.
-     * @throws {ApiRequestError} When the API returns an error 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/for-developers/api/exchange-endpoint#core-spot-transfer
      * @example
@@ -1131,7 +1334,7 @@ export class ExchangeClient {
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
-     * const data = await exchClient.spotSend({
+     * await exchClient.spotSend({
      *   destination: "0x...",
      *   token: "USDC:0xeb62eee3685fc4c43992febcd9e75443",
      *   amount: "1",
@@ -1143,31 +1346,34 @@ export class ExchangeClient {
         const { ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            ...actionArgs,
+        const action = actionSorter.spotSend({
             type: "spotSend",
             hyperliquidChain: this._getHyperliquidChain(),
             signatureChainId: await this._getSignatureChainId(),
             time: nonce,
-        };
+            ...actionArgs,
+        });
         // Sign the action
         const signature = await signUserSignedAction({
             wallet: this.wallet,
             action,
             types: userSignedActionEip712Types[action.type],
-            chainId: parseInt(action.signatureChainId, 16),
         });
         // Send a request
-        return await this._request({ action, signature, nonce }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Opt Out of Spot Dusting.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful response without specific data.
-     * @throws {ApiRequestError} When the API returns an error response.
      *
-     * @see null - no documentation
+     * @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";
@@ -1176,7 +1382,7 @@ export class ExchangeClient {
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
-     * const data = await exchClient.spotUser({ toggleSpotDusting: { optOut: false } });
+     * await exchClient.spotUser({ toggleSpotDusting: { optOut: false } });
      * ```
      */
     async spotUser(args, signal) {
@@ -1184,28 +1390,29 @@ export class ExchangeClient {
         const { ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            type: "spotUser",
-            ...actionArgs,
-        };
+        const action = actionSorter.spotUser({ type: "spotUser", ...actionArgs });
         // Sign the action
         const signature = await signL1Action({
             wallet: this.wallet,
-            action: actionSorter[action.type](action),
+            action,
             nonce,
             isTestnet: this.isTestnet,
         });
         // Send a request
-        return await this._request({ action, signature, nonce }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Transfer between sub-accounts (spot).
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful response without specific data.
-     * @throws {ApiRequestError} When the API returns an error response.
      *
-     * @see null - no documentation
+     * @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";
@@ -1214,7 +1421,7 @@ export class ExchangeClient {
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
-     * const data = await exchClient.subAccountSpotTransfer({
+     * await exchClient.subAccountSpotTransfer({
      *   subAccountUser: "0x...",
      *   isDeposit: true,
      *   token: "USDC:0xeb62eee3685fc4c43992febcd9e75443",
@@ -1227,28 +1434,29 @@ export class ExchangeClient {
         const { ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            type: "subAccountSpotTransfer",
-            ...actionArgs,
-        };
+        const action = actionSorter.subAccountSpotTransfer({ type: "subAccountSpotTransfer", ...actionArgs });
         // Sign the action
         const signature = await signL1Action({
             wallet: this.wallet,
-            action: actionSorter[action.type](action),
+            action,
             nonce,
             isTestnet: this.isTestnet,
         });
         // Send a request
-        return await this._request({ action, signature, nonce }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Transfer between sub-accounts (perpetual).
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful response without specific data.
-     * @throws {ApiRequestError} When the API returns an error response.
      *
-     * @see null - no documentation
+     * @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";
@@ -1257,11 +1465,7 @@ export class ExchangeClient {
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
-     * const data = await exchClient.subAccountTransfer({
-     *   subAccountUser: "0x...",
-     *   isDeposit: true,
-     *   usd: 1 * 1e6,
-     * });
+     * await exchClient.subAccountTransfer({ subAccountUser: "0x...", isDeposit: true, usd: 1 * 1e6 });
      * ```
      */
     async subAccountTransfer(args, signal) {
@@ -1269,26 +1473,27 @@ export class ExchangeClient {
         const { ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            type: "subAccountTransfer",
-            ...actionArgs,
-        };
+        const action = actionSorter.subAccountTransfer({ type: "subAccountTransfer", ...actionArgs });
         // Sign the action
         const signature = await signL1Action({
             wallet: this.wallet,
-            action: actionSorter[action.type](action),
+            action,
             nonce,
             isTestnet: this.isTestnet,
         });
         // Send a request
-        return await this._request({ action, signature, nonce }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Delegate or undelegate native tokens to or from a validator.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful response without specific data.
-     * @throws {ApiRequestError} When the API returns an error 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/for-developers/api/exchange-endpoint#delegate-or-undelegate-stake-from-validator
      * @example
@@ -1299,11 +1504,7 @@ export class ExchangeClient {
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
-     * const data = await exchClient.tokenDelegate({
-     *   validator: "0x...",
-     *   isUndelegate: true,
-     *   wei: 1 * 1e8,
-     * });
+     * await exchClient.tokenDelegate({ validator: "0x...", isUndelegate: true, wei: 1 * 1e8 });
      * ```
      */
     async tokenDelegate(args, signal) {
@@ -1311,29 +1512,32 @@ export class ExchangeClient {
         const { ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            ...actionArgs,
+        const action = actionSorter.tokenDelegate({
             type: "tokenDelegate",
             hyperliquidChain: this._getHyperliquidChain(),
             signatureChainId: await this._getSignatureChainId(),
             nonce,
-        };
+            ...actionArgs,
+        });
         // Sign the action
         const signature = await signUserSignedAction({
             wallet: this.wallet,
             action,
             types: userSignedActionEip712Types[action.type],
-            chainId: parseInt(action.signatureChainId, 16),
         });
         // Send a request
-        return await this._request({ action, signature, nonce }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Cancel a TWAP order.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful variant of {@link TwapCancelResponse} without error status.
-     * @throws {ApiRequestError} When the API returns an error 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/for-developers/api/exchange-endpoint#cancel-a-twap-order
      * @example
@@ -1344,10 +1548,7 @@ export class ExchangeClient {
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
-     * const data = await exchClient.twapCancel({
-     *   a: 0, // Asset index
-     *   t: 1, // TWAP ID
-     * });
+     * const data = await exchClient.twapCancel({ a: 0, t: 1 });
      * ```
      */
     async twapCancel(args, signal) {
@@ -1355,28 +1556,29 @@ export class ExchangeClient {
         const { vaultAddress = this.defaultVaultAddress, expiresAfter = await this._getDefaultExpiresAfter(), ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            type: "twapCancel",
-            ...actionArgs,
-        };
+        const action = actionSorter.twapCancel({ type: "twapCancel", ...actionArgs });
         // Sign the action
         const signature = await signL1Action({
             wallet: this.wallet,
-            action: actionSorter[action.type](action),
+            action,
             nonce,
             isTestnet: this.isTestnet,
             vaultAddress,
             expiresAfter,
         });
         // Send a request
-        return await this._request({ action, signature, nonce, vaultAddress, expiresAfter }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce, vaultAddress, expiresAfter }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Place a TWAP order.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful variant of {@link TwapOrderResponse} without error status.
-     * @throws {ApiRequestError} When the API returns an error 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/for-developers/api/exchange-endpoint#place-a-twap-order
      * @example
@@ -1388,12 +1590,12 @@ export class ExchangeClient {
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
      * const data = await exchClient.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
+     *   a: 0,
+     *   b: true,
+     *   s: "1",
+     *   r: false,
+     *   m: 10,
+     *   t: true,
      * });
      * ```
      */
@@ -1402,30 +1604,29 @@ export class ExchangeClient {
         const { vaultAddress = this.defaultVaultAddress, expiresAfter = await this._getDefaultExpiresAfter(), ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            type: "twapOrder",
-            twap: {
-                ...actionArgs,
-            },
-        };
+        const action = actionSorter.twapOrder({ type: "twapOrder", twap: { ...actionArgs } });
         // Sign the action
         const signature = await signL1Action({
             wallet: this.wallet,
-            action: actionSorter[action.type](action),
+            action,
             nonce,
             isTestnet: this.isTestnet,
             vaultAddress,
             expiresAfter,
         });
         // Send a request
-        return await this._request({ action, signature, nonce, vaultAddress, expiresAfter }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce, vaultAddress, expiresAfter }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Add or remove margin from isolated position.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful response without specific data.
-     * @throws {ApiRequestError} When the API returns an error 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/for-developers/api/exchange-endpoint#update-isolated-margin
      * @example
@@ -1436,11 +1637,7 @@ export class ExchangeClient {
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
-     * const data = await exchClient.updateIsolatedMargin({
-     *   asset: 0,
-     *   isBuy: true,
-     *   ntli: 1 * 1e6,
-     * });
+     * await exchClient.updateIsolatedMargin({ asset: 0, isBuy: true, ntli: 1 * 1e6 });
      * ```
      */
     async updateIsolatedMargin(args, signal) {
@@ -1448,28 +1645,29 @@ export class ExchangeClient {
         const { vaultAddress = this.defaultVaultAddress, expiresAfter = await this._getDefaultExpiresAfter(), ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            type: "updateIsolatedMargin",
-            ...actionArgs,
-        };
+        const action = actionSorter.updateIsolatedMargin({ type: "updateIsolatedMargin", ...actionArgs });
         // Sign the action
         const signature = await signL1Action({
             wallet: this.wallet,
-            action: actionSorter[action.type](action),
+            action,
             nonce,
             isTestnet: this.isTestnet,
             vaultAddress,
             expiresAfter,
         });
         // Send a request
-        return await this._request({ action, signature, nonce, vaultAddress, expiresAfter }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce, vaultAddress, expiresAfter }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Update cross or isolated leverage on a coin.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful response without specific data.
-     * @throws {ApiRequestError} When the API returns an error 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/for-developers/api/exchange-endpoint#update-leverage
      * @example
@@ -1480,11 +1678,7 @@ export class ExchangeClient {
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
-     * const data = await exchClient.updateLeverage({
-     *   asset: 0,
-     *   isCross: true,
-     *   leverage: 5,
-     * });
+     * await exchClient.updateLeverage({ asset: 0, isCross: true, leverage: 5 });
      * ```
      */
     async updateLeverage(args, signal) {
@@ -1492,28 +1686,29 @@ export class ExchangeClient {
         const { vaultAddress = this.defaultVaultAddress, expiresAfter = await this._getDefaultExpiresAfter(), ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            type: "updateLeverage",
-            ...actionArgs,
-        };
+        const action = actionSorter.updateLeverage({ type: "updateLeverage", ...actionArgs });
         // Sign the action
         const signature = await signL1Action({
             wallet: this.wallet,
-            action: actionSorter[action.type](action),
+            action,
             nonce,
             isTestnet: this.isTestnet,
             vaultAddress,
             expiresAfter,
         });
         // Send a request
-        return await this._request({ action, signature, nonce, vaultAddress, expiresAfter }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce, vaultAddress, expiresAfter }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Transfer funds between Spot account and Perp account.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful response without specific data.
-     * @throws {ApiRequestError} When the API returns an error 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/for-developers/api/exchange-endpoint#transfer-from-spot-account-to-perp-account-and-vice-versa
      * @example
@@ -1524,7 +1719,7 @@ export class ExchangeClient {
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
-     * const data = await exchClient.usdClassTransfer({ amount: "1", toPerp: true });
+     * await exchClient.usdClassTransfer({ amount: "1", toPerp: true });
      * ```
      */
     async usdClassTransfer(args, signal) {
@@ -1532,29 +1727,32 @@ export class ExchangeClient {
         const { ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            ...actionArgs,
+        const action = actionSorter.usdClassTransfer({
             type: "usdClassTransfer",
             hyperliquidChain: this._getHyperliquidChain(),
             signatureChainId: await this._getSignatureChainId(),
             nonce,
-        };
+            ...actionArgs,
+        });
         // Sign the action
         const signature = await signUserSignedAction({
             wallet: this.wallet,
             action,
             types: userSignedActionEip712Types[action.type],
-            chainId: parseInt(action.signatureChainId, 16),
         });
         // Send a request
-        return await this._request({ action, signature, nonce }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Send usd to another address.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful response without specific data.
-     * @throws {ApiRequestError} When the API returns an error 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/for-developers/api/exchange-endpoint#core-usdc-transfer
      * @example
@@ -1565,7 +1763,7 @@ export class ExchangeClient {
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
-     * const data = await exchClient.usdSend({ destination: "0x...", amount: "1" });
+     * await exchClient.usdSend({ destination: "0x...", amount: "1" });
      * ```
      */
     async usdSend(args, signal) {
@@ -1573,31 +1771,34 @@ export class ExchangeClient {
         const { ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            ...actionArgs,
+        const action = actionSorter.usdSend({
             type: "usdSend",
             hyperliquidChain: this._getHyperliquidChain(),
             signatureChainId: await this._getSignatureChainId(),
             time: nonce,
-        };
+            ...actionArgs,
+        });
         // Sign the action
         const signature = await signUserSignedAction({
             wallet: this.wallet,
             action,
             types: userSignedActionEip712Types[action.type],
-            chainId: parseInt(action.signatureChainId, 16),
         });
         // Send a request
-        return await this._request({ action, signature, nonce }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Distribute funds from a vault between followers.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful response without specific data.
-     * @throws {ApiRequestError} When the API returns an error response.
      *
-     * @see null - no documentation
+     * @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";
@@ -1606,7 +1807,7 @@ export class ExchangeClient {
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
-     * const data = await exchClient.vaultDistribute({ vaultAddress: "0x...", usd: 10 * 1e6 });
+     * await exchClient.vaultDistribute({ vaultAddress: "0x...", usd: 10 * 1e6 });
      * ```
      */
     async vaultDistribute(args, signal) {
@@ -1614,28 +1815,29 @@ export class ExchangeClient {
         const { ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            type: "vaultDistribute",
-            ...actionArgs,
-        };
+        const action = actionSorter.vaultDistribute({ type: "vaultDistribute", ...actionArgs });
         // Sign the action
         const signature = await signL1Action({
             wallet: this.wallet,
-            action: actionSorter[action.type](action),
+            action,
             nonce,
             isTestnet: this.isTestnet,
         });
         // Send a request
-        return await this._request({ action, signature, nonce }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Modify a vault's configuration.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful response without specific data.
-     * @throws {ApiRequestError} When the API returns an error response.
      *
-     * @see null - no documentation
+     * @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";
@@ -1644,7 +1846,7 @@ export class ExchangeClient {
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
-     * const data = await exchClient.vaultModify({
+     * await exchClient.vaultModify({
      *   vaultAddress: "0x...",
      *   allowDeposits: true,
      *   alwaysCloseOnWithdraw: false,
@@ -1656,26 +1858,27 @@ export class ExchangeClient {
         const { ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            type: "vaultModify",
-            ...actionArgs,
-        };
+        const action = actionSorter.vaultModify({ type: "vaultModify", ...actionArgs });
         // Sign the action
         const signature = await signL1Action({
             wallet: this.wallet,
-            action: actionSorter[action.type](action),
+            action,
             nonce,
             isTestnet: this.isTestnet,
         });
         // Send a request
-        return await this._request({ action, signature, nonce }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Deposit or withdraw from a vault.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful response without specific data.
-     * @throws {ApiRequestError} When the API returns an error 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/for-developers/api/exchange-endpoint#deposit-or-withdraw-from-a-vault
      * @example
@@ -1686,11 +1889,7 @@ export class ExchangeClient {
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
-     * const data = await exchClient.vaultTransfer({
-     *   vaultAddress: "0x...",
-     *   isDeposit: true,
-     *   usd: 10 * 1e6,
-     * });
+     * await exchClient.vaultTransfer({ vaultAddress: "0x...", isDeposit: true, usd: 10 * 1e6 });
      * ```
      */
     async vaultTransfer(args, signal) {
@@ -1698,27 +1897,28 @@ export class ExchangeClient {
         const { expiresAfter = await this._getDefaultExpiresAfter(), ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            type: "vaultTransfer",
-            ...actionArgs,
-        };
+        const action = actionSorter.vaultTransfer({ type: "vaultTransfer", ...actionArgs });
         // Sign the action
         const signature = await signL1Action({
             wallet: this.wallet,
-            action: actionSorter[action.type](action),
+            action,
             nonce,
             isTestnet: this.isTestnet,
             expiresAfter,
         });
         // Send a request
-        return await this._request({ action, signature, nonce, expiresAfter }, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce, expiresAfter }, signal);
+        this._validateResponse(response);
+        return response;
     }
     /**
      * Initiate a withdrawal request.
      * @param args - The parameters for the request.
      * @param signal - An optional abort signal.
      * @returns Successful response without specific data.
-     * @throws {ApiRequestError} When the API returns an error 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/for-developers/api/exchange-endpoint#initiate-a-withdrawal-request
      * @example
@@ -1729,7 +1929,7 @@ export class ExchangeClient {
      * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
      * const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });
      *
-     * const data = await exchClient.withdraw3({ destination: "0x...", amount: "1" });
+     * await exchClient.withdraw3({ destination: "0x...", amount: "1" });
      * ```
      */
     async withdraw3(args, signal) {
@@ -1737,26 +1937,21 @@ export class ExchangeClient {
         const { ...actionArgs } = args;
         // Construct an action
         const nonce = await this.nonceManager();
-        const action = {
-            ...actionArgs,
+        const action = actionSorter.withdraw3({
             type: "withdraw3",
             hyperliquidChain: this._getHyperliquidChain(),
             signatureChainId: await this._getSignatureChainId(),
             time: nonce,
-        };
+            ...actionArgs,
+        });
         // Sign the action
         const signature = await signUserSignedAction({
             wallet: this.wallet,
             action,
             types: userSignedActionEip712Types[action.type],
-            chainId: parseInt(action.signatureChainId, 16),
         });
         // Send a request
-        return await this._request({ action, signature, nonce }, signal);
-    }
-    /** Send an API request and validate the response. */
-    async _request(payload, signal) {
-        const response = await this.transport.request("exchange", payload, signal);
+        const response = await this.transport.request("exchange", { action, signature, nonce }, signal);
         this._validateResponse(response);
         return response;
     }