@nktkas/hyperliquid 0.25.7 → 0.25.9

package/src/src/api/exchange/approveAgent.ts

@@ -6,7 +6,6 @@ import {
   type ExtractRequestAction,
   type ExtractRequestOptions,
   getSignatureChainId,
-  globalNonceManager,
   type MultiSignRequestConfig,
   Signature,
 } from "./_base/mod.js";
@@ -123,16 +122,20 @@ export async function approveAgent(
   params: DeepImmutable<ApproveAgentParameters>,
   opts?: ApproveAgentOptions,
 ): Promise<SuccessResponse> {
-  const action = parser(ApproveAgentRequest.entries.action)({
-    type: "approveAgent",
-    hyperliquidChain: config.transport.isTestnet ? "Testnet" : "Mainnet",
-    signatureChainId: await getSignatureChainId(config),
-    nonce: globalNonceManager.getNonce(),
-    ...params,
+  const request = parser(ApproveAgentRequest)({
+    action: {
+      type: "approveAgent",
+      hyperliquidChain: config.transport.isTestnet ? "Testnet" : "Mainnet",
+      signatureChainId: await getSignatureChainId(config),
+      nonce: 0, // Placeholder; actual nonce generated in `executeUserSignedAction` to prevent race conditions
+      ...params,
+    },
+    nonce: 0, // Placeholder; actual nonce generated in `executeUserSignedAction` to prevent race conditions
+    signature: { // Placeholder; actual signature generated in `executeUserSignedAction`
+      r: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      s: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      v: 27,
+    },
   });
-  return await executeUserSignedAction(
-    config,
-    { action, types: ApproveAgentTypes },
-    opts?.signal,
-  );
+  return await executeUserSignedAction(config, request, ApproveAgentTypes, opts?.signal);
 }

package/src/src/api/exchange/approveBuilderFee.ts

@@ -6,7 +6,6 @@ import {
   type ExtractRequestAction,
   type ExtractRequestOptions,
   getSignatureChainId,
-  globalNonceManager,
   type MultiSignRequestConfig,
   Signature,
 } from "./_base/mod.js";
@@ -123,16 +122,20 @@ export async function approveBuilderFee(
   params: DeepImmutable<ApproveBuilderFeeParameters>,
   opts?: ApproveBuilderFeeOptions,
 ): Promise<SuccessResponse> {
-  const action = parser(ApproveBuilderFeeRequest.entries.action)({
-    type: "approveBuilderFee",
-    hyperliquidChain: config.transport.isTestnet ? "Testnet" : "Mainnet",
-    signatureChainId: await getSignatureChainId(config),
-    nonce: globalNonceManager.getNonce(),
-    ...params,
+  const request = parser(ApproveBuilderFeeRequest)({
+    action: {
+      type: "approveBuilderFee",
+      hyperliquidChain: config.transport.isTestnet ? "Testnet" : "Mainnet",
+      signatureChainId: await getSignatureChainId(config),
+      nonce: 0, // Placeholder; actual nonce generated in `executeUserSignedAction` to prevent race conditions
+      ...params,
+    },
+    nonce: 0, // Placeholder; actual nonce generated in `executeUserSignedAction` to prevent race conditions
+    signature: { // Placeholder; actual signature generated in `executeUserSignedAction`
+      r: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      s: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      v: 27,
+    },
   });
-  return await executeUserSignedAction(
-    config,
-    { action, types: ApproveBuilderFeeTypes },
-    opts?.signal,
-  );
+  return await executeUserSignedAction(config, request, ApproveBuilderFeeTypes, opts?.signal);
 }

package/src/src/api/exchange/batchModify.ts

@@ -128,18 +128,21 @@ export async function batchModify(
   params: DeepImmutable<BatchModifyParameters>,
   opts?: BatchModifyOptions,
 ): Promise<OrderSuccessResponse> {
-  const action = parser(BatchModifyRequest.entries.action)({
-    type: "batchModify",
-    ...params,
+  const request = parser(BatchModifyRequest)({
+    action: {
+      type: "batchModify",
+      ...params,
+    },
+    nonce: 0, // Placeholder; actual nonce generated in `executeL1Action`
+    signature: { // Placeholder; actual signature generated in `executeL1Action`
+      r: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      s: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      v: 27,
+    },
+    vaultAddress: opts?.vaultAddress ?? config.defaultVaultAddress,
+    expiresAfter: typeof config.defaultExpiresAfter === "number"
+      ? config.defaultExpiresAfter
+      : await config.defaultExpiresAfter?.(),
   });
-
-  const vaultAddress_ = opts?.vaultAddress ?? config.defaultVaultAddress;
-  const vaultAddress = parser(v.optional(Address))(vaultAddress_);
-
-  const expiresAfter_ = typeof config.defaultExpiresAfter === "number"
-    ? config.defaultExpiresAfter
-    : await config.defaultExpiresAfter?.();
-  const expiresAfter = parser(v.optional(UnsignedInteger))(expiresAfter_);
-
-  return await executeL1Action(config, { action, vaultAddress, expiresAfter }, opts?.signal);
+  return await executeL1Action(config, request, opts?.signal);
 }

package/src/src/api/exchange/cDeposit.ts

@@ -6,7 +6,6 @@ import {
   type ExtractRequestAction,
   type ExtractRequestOptions,
   getSignatureChainId,
-  globalNonceManager,
   type MultiSignRequestConfig,
   Signature,
 } from "./_base/mod.js";
@@ -117,16 +116,20 @@ export async function cDeposit(
   params: DeepImmutable<CDepositParameters>,
   opts?: CDepositOptions,
 ): Promise<SuccessResponse> {
-  const action = parser(CDepositRequest.entries.action)({
-    type: "cDeposit",
-    hyperliquidChain: config.transport.isTestnet ? "Testnet" : "Mainnet",
-    signatureChainId: await getSignatureChainId(config),
-    nonce: globalNonceManager.getNonce(),
-    ...params,
+  const request = parser(CDepositRequest)({
+    action: {
+      type: "cDeposit",
+      hyperliquidChain: config.transport.isTestnet ? "Testnet" : "Mainnet",
+      signatureChainId: await getSignatureChainId(config),
+      nonce: 0, // Placeholder; actual nonce generated in `executeUserSignedAction` to prevent race conditions
+      ...params,
+    },
+    nonce: 0, // Placeholder; actual nonce generated in `executeUserSignedAction` to prevent race conditions
+    signature: { // Placeholder; actual signature generated in `executeUserSignedAction`
+      r: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      s: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      v: 27,
+    },
   });
-  return await executeUserSignedAction(
-    config,
-    { action, types: CDepositTypes },
-    opts?.signal,
-  );
+  return await executeUserSignedAction(config, request, CDepositTypes, opts?.signal);
 }

package/src/src/api/exchange/cSignerAction.ts

@@ -117,15 +117,20 @@ export async function cSignerAction(
   params: DeepImmutable<CSignerActionParameters>,
   opts?: CSignerActionOptions,
 ): Promise<SuccessResponse> {
-  const action = parser(CSignerActionRequest.entries.action)({
-    type: "CSignerAction",
-    ...params,
+  const request = parser(CSignerActionRequest)({
+    action: {
+      type: "CSignerAction",
+      ...params,
+    },
+    nonce: 0, // Placeholder; actual nonce generated in `executeL1Action`
+    signature: { // Placeholder; actual signature generated in `executeL1Action`
+      r: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      s: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      v: 27,
+    },
+    expiresAfter: typeof config.defaultExpiresAfter === "number"
+      ? config.defaultExpiresAfter
+      : await config.defaultExpiresAfter?.(),
   });
-
-  const expiresAfter_ = typeof config.defaultExpiresAfter === "number"
-    ? config.defaultExpiresAfter
-    : await config.defaultExpiresAfter?.();
-  const expiresAfter = parser(v.optional(UnsignedInteger))(expiresAfter_);
-
-  return await executeL1Action(config, { action, expiresAfter }, opts?.signal);
+  return await executeL1Action(config, request, opts?.signal);
 }

package/src/src/api/exchange/cValidatorAction.ts

@@ -257,15 +257,20 @@ export async function cValidatorAction(
   params: DeepImmutable<CValidatorActionParameters>,
   opts?: CValidatorActionOptions,
 ): Promise<SuccessResponse> {
-  const action = parser(CValidatorActionRequest.entries.action)({
-    type: "CValidatorAction",
-    ...params,
+  const request = parser(CValidatorActionRequest)({
+    action: {
+      type: "CValidatorAction",
+      ...params,
+    },
+    nonce: 0, // Placeholder; actual nonce generated in `executeL1Action`
+    signature: { // Placeholder; actual signature generated in `executeL1Action`
+      r: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      s: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      v: 27,
+    },
+    expiresAfter: typeof config.defaultExpiresAfter === "number"
+      ? config.defaultExpiresAfter
+      : await config.defaultExpiresAfter?.(),
   });
-
-  const expiresAfter_ = typeof config.defaultExpiresAfter === "number"
-    ? config.defaultExpiresAfter
-    : await config.defaultExpiresAfter?.();
-  const expiresAfter = parser(v.optional(UnsignedInteger))(expiresAfter_);
-
-  return await executeL1Action(config, { action, expiresAfter }, opts?.signal);
+  return await executeL1Action(config, request, opts?.signal);
 }

package/src/src/api/exchange/cWithdraw.ts

@@ -6,7 +6,6 @@ import {
   type ExtractRequestAction,
   type ExtractRequestOptions,
   getSignatureChainId,
-  globalNonceManager,
   type MultiSignRequestConfig,
   Signature,
 } from "./_base/mod.js";
@@ -117,16 +116,20 @@ export async function cWithdraw(
   params: DeepImmutable<CWithdrawParameters>,
   opts?: CWithdrawOptions,
 ): Promise<SuccessResponse> {
-  const action = parser(CWithdrawRequest.entries.action)({
-    type: "cWithdraw",
-    hyperliquidChain: config.transport.isTestnet ? "Testnet" : "Mainnet",
-    signatureChainId: await getSignatureChainId(config),
-    nonce: globalNonceManager.getNonce(),
-    ...params,
+  const request = parser(CWithdrawRequest)({
+    action: {
+      type: "cWithdraw",
+      hyperliquidChain: config.transport.isTestnet ? "Testnet" : "Mainnet",
+      signatureChainId: await getSignatureChainId(config),
+      nonce: 0, // Placeholder; actual nonce generated in `executeUserSignedAction` to prevent race conditions
+      ...params,
+    },
+    nonce: 0, // Placeholder; actual nonce generated in `executeUserSignedAction` to prevent race conditions
+    signature: { // Placeholder; actual signature generated in `executeUserSignedAction`
+      r: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      s: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      v: 27,
+    },
   });
-  return await executeUserSignedAction(
-    config,
-    { action, types: CWithdrawTypes },
-    opts?.signal,
-  );
+  return await executeUserSignedAction(config, request, CWithdrawTypes, opts?.signal);
 }

package/src/src/api/exchange/cancel.ts

@@ -198,18 +198,21 @@ export async function cancel(
   params: DeepImmutable<CancelParameters>,
   opts?: CancelOptions,
 ): Promise<CancelSuccessResponse> {
-  const action = parser(CancelRequest.entries.action)({
-    type: "cancel",
-    ...params,
+  const request = parser(CancelRequest)({
+    action: {
+      type: "cancel",
+      ...params,
+    },
+    nonce: 0, // Placeholder; actual nonce generated in `executeL1Action`
+    signature: { // Placeholder; actual signature generated in `executeL1Action`
+      r: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      s: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      v: 27,
+    },
+    vaultAddress: opts?.vaultAddress ?? config.defaultVaultAddress,
+    expiresAfter: typeof config.defaultExpiresAfter === "number"
+      ? config.defaultExpiresAfter
+      : await config.defaultExpiresAfter?.(),
   });
-
-  const vaultAddress_ = opts?.vaultAddress ?? config.defaultVaultAddress;
-  const vaultAddress = parser(v.optional(Address))(vaultAddress_);
-
-  const expiresAfter_ = typeof config.defaultExpiresAfter === "number"
-    ? config.defaultExpiresAfter
-    : await config.defaultExpiresAfter?.();
-  const expiresAfter = parser(v.optional(UnsignedInteger))(expiresAfter_);
-
-  return await executeL1Action(config, { action, vaultAddress, expiresAfter }, opts?.signal);
+  return await executeL1Action(config, request, opts?.signal);
 }

package/src/src/api/exchange/cancelByCloid.ts

@@ -116,18 +116,21 @@ export async function cancelByCloid(
   params: DeepImmutable<CancelByCloidParameters>,
   opts?: CancelByCloidOptions,
 ): Promise<CancelSuccessResponse> {
-  const action = parser(CancelByCloidRequest.entries.action)({
-    type: "cancelByCloid",
-    ...params,
+  const request = parser(CancelByCloidRequest)({
+    action: {
+      type: "cancelByCloid",
+      ...params,
+    },
+    nonce: 0, // Placeholder; actual nonce generated in `executeL1Action`
+    signature: { // Placeholder; actual signature generated in `executeL1Action`
+      r: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      s: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      v: 27,
+    },
+    vaultAddress: opts?.vaultAddress ?? config.defaultVaultAddress,
+    expiresAfter: typeof config.defaultExpiresAfter === "number"
+      ? config.defaultExpiresAfter
+      : await config.defaultExpiresAfter?.(),
   });
-
-  const vaultAddress_ = opts?.vaultAddress ?? config.defaultVaultAddress;
-  const vaultAddress = parser(v.optional(Address))(vaultAddress_);
-
-  const expiresAfter_ = typeof config.defaultExpiresAfter === "number"
-    ? config.defaultExpiresAfter
-    : await config.defaultExpiresAfter?.();
-  const expiresAfter = parser(v.optional(UnsignedInteger))(expiresAfter_);
-
-  return await executeL1Action(config, { action, vaultAddress, expiresAfter }, opts?.signal);
+  return await executeL1Action(config, request, opts?.signal);
 }

package/src/src/api/exchange/claimRewards.ts

@@ -82,14 +82,19 @@ export async function claimRewards(
   config: ExchangeRequestConfig | MultiSignRequestConfig,
   opts?: ClaimRewardsOptions,
 ): Promise<SuccessResponse> {
-  const action = parser(ClaimRewardsRequest.entries.action)({
-    type: "claimRewards",
+  const request = parser(ClaimRewardsRequest)({
+    action: {
+      type: "claimRewards",
+    },
+    nonce: 0, // Placeholder; actual nonce generated in `executeL1Action`
+    signature: { // Placeholder; actual signature generated in `executeL1Action`
+      r: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      s: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      v: 27,
+    },
+    expiresAfter: typeof config.defaultExpiresAfter === "number"
+      ? config.defaultExpiresAfter
+      : await config.defaultExpiresAfter?.(),
   });
-
-  const expiresAfter_ = typeof config.defaultExpiresAfter === "number"
-    ? config.defaultExpiresAfter
-    : await config.defaultExpiresAfter?.();
-  const expiresAfter = parser(v.optional(UnsignedInteger))(expiresAfter_);
-
-  return await executeL1Action(config, { action, expiresAfter }, opts?.signal);
+  return await executeL1Action(config, request, opts?.signal);
 }

package/src/src/api/exchange/convertToMultiSigUser.ts

@@ -6,7 +6,6 @@ import {
   type ExtractRequestAction,
   type ExtractRequestOptions,
   getSignatureChainId,
-  globalNonceManager,
   type MultiSignRequestConfig,
   Signature,
 } from "./_base/mod.js";
@@ -174,16 +173,20 @@ export async function convertToMultiSigUser(
   params: DeepImmutable<ConvertToMultiSigUserParameters>,
   opts?: ConvertToMultiSigUserOptions,
 ): Promise<SuccessResponse> {
-  const action = parser(ConvertToMultiSigUserRequest.entries.action)({
-    type: "convertToMultiSigUser",
-    hyperliquidChain: config.transport.isTestnet ? "Testnet" : "Mainnet",
-    signatureChainId: await getSignatureChainId(config),
-    nonce: globalNonceManager.getNonce(),
-    ...params,
+  const request = parser(ConvertToMultiSigUserRequest)({
+    action: {
+      type: "convertToMultiSigUser",
+      hyperliquidChain: config.transport.isTestnet ? "Testnet" : "Mainnet",
+      signatureChainId: await getSignatureChainId(config),
+      nonce: 0, // Placeholder; actual nonce generated in `executeUserSignedAction` to prevent race conditions
+      ...params,
+    },
+    nonce: 0, // Placeholder; actual nonce generated in `executeUserSignedAction` to prevent race conditions
+    signature: { // Placeholder; actual signature generated in `executeUserSignedAction`
+      r: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      s: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      v: 27,
+    },
   });
-  return await executeUserSignedAction(
-    config,
-    { action, types: ConvertToMultiSigUserTypes },
-    opts?.signal,
-  );
+  return await executeUserSignedAction(config, request, ConvertToMultiSigUserTypes, opts?.signal);
 }

package/src/src/api/exchange/createSubAccount.ts

@@ -125,15 +125,20 @@ export async function createSubAccount(
   params: DeepImmutable<CreateSubAccountParameters>,
   opts?: CreateSubAccountOptions,
 ): Promise<CreateSubAccountResponse> {
-  const action = parser(CreateSubAccountRequest.entries.action)({
-    type: "createSubAccount",
-    ...params,
+  const request = parser(CreateSubAccountRequest)({
+    action: {
+      type: "createSubAccount",
+      ...params,
+    },
+    nonce: 0, // Placeholder; actual nonce generated in `executeL1Action`
+    signature: { // Placeholder; actual signature generated in `executeL1Action`
+      r: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      s: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      v: 27,
+    },
+    expiresAfter: typeof config.defaultExpiresAfter === "number"
+      ? config.defaultExpiresAfter
+      : await config.defaultExpiresAfter?.(),
   });
-
-  const expiresAfter_ = typeof config.defaultExpiresAfter === "number"
-    ? config.defaultExpiresAfter
-    : await config.defaultExpiresAfter?.();
-  const expiresAfter = parser(v.optional(UnsignedInteger))(expiresAfter_);
-
-  return await executeL1Action(config, { action, expiresAfter }, opts?.signal);
+  return await executeL1Action(config, request, opts?.signal);
 }

package/src/src/api/exchange/createVault.ts

@@ -146,15 +146,20 @@ export async function createVault(
   params: DeepImmutable<CreateVaultParameters>,
   opts?: CreateVaultOptions,
 ): Promise<CreateVaultResponse> {
-  const action = parser(CreateVaultRequest.entries.action)({
-    type: "createVault",
-    ...params,
+  const request = parser(CreateVaultRequest)({
+    action: {
+      type: "createVault",
+      ...params,
+    },
+    nonce: 0, // Placeholder; actual nonce generated in `executeL1Action`
+    signature: { // Placeholder; actual signature generated in `executeL1Action`
+      r: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      s: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      v: 27,
+    },
+    expiresAfter: typeof config.defaultExpiresAfter === "number"
+      ? config.defaultExpiresAfter
+      : await config.defaultExpiresAfter?.(),
   });
-
-  const expiresAfter_ = typeof config.defaultExpiresAfter === "number"
-    ? config.defaultExpiresAfter
-    : await config.defaultExpiresAfter?.();
-  const expiresAfter = parser(v.optional(UnsignedInteger))(expiresAfter_);
-
-  return await executeL1Action(config, { action, expiresAfter }, opts?.signal);
+  return await executeL1Action(config, request, opts?.signal);
 }

package/src/src/api/exchange/evmUserModify.ts

@@ -70,7 +70,7 @@ export type EvmUserModifyOptions = ExtractRequestOptions<v.InferInput<typeof Evm
  * @param config - General configuration for Exchange API requests.
  * @param params - Parameters specific to the API request.
  * @param opts - Request execution options.
- * @returns Response for creating a sub-account.
+ * @returns Successful response without specific data.
  *
  * @throws {ApiRequestError} When the API returns an unsuccessful response.
  * @throws {TransportError} When the transport layer throws an error.
@@ -96,15 +96,20 @@ export async function evmUserModify(
   params: DeepImmutable<EvmUserModifyParameters>,
   opts?: EvmUserModifyOptions,
 ): Promise<SuccessResponse> {
-  const action = parser(EvmUserModifyRequest.entries.action)({
-    type: "evmUserModify",
-    ...params,
+  const request = parser(EvmUserModifyRequest)({
+    action: {
+      type: "evmUserModify",
+      ...params,
+    },
+    nonce: 0, // Placeholder; actual nonce generated in `executeL1Action`
+    signature: { // Placeholder; actual signature generated in `executeL1Action`
+      r: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      s: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      v: 27,
+    },
+    expiresAfter: typeof config.defaultExpiresAfter === "number"
+      ? config.defaultExpiresAfter
+      : await config.defaultExpiresAfter?.(),
   });
-
-  const expiresAfter_ = typeof config.defaultExpiresAfter === "number"
-    ? config.defaultExpiresAfter
-    : await config.defaultExpiresAfter?.();
-  const expiresAfter = parser(v.optional(UnsignedInteger))(expiresAfter_);
-
-  return await executeL1Action(config, { action, expiresAfter }, opts?.signal);
+  return await executeL1Action(config, request, opts?.signal);
 }

package/src/src/api/exchange/linkStakingUser.ts

@@ -0,0 +1,157 @@
+import * as v from "valibot";
+import { Address, type DeepImmutable, Hex, parser, UnsignedInteger } from "../_base.js";
+import {
+  type ExchangeRequestConfig,
+  executeUserSignedAction,
+  type ExtractRequestAction,
+  type ExtractRequestOptions,
+  getSignatureChainId,
+  type MultiSignRequestConfig,
+  Signature,
+} from "./_base/mod.js";
+
+// -------------------- Schemas --------------------
+
+/**
+ * Link staking and trading accounts for fee discount attribution.
+ * @see https://hyperliquid.gitbook.io/hyperliquid-docs/trading/fees#staking-linking
+ */
+export const LinkStakingUserRequest = /* @__PURE__ */ (() => {
+  return v.pipe(
+    v.object({
+      /** Action to perform. */
+      action: v.pipe(
+        v.object({
+          /** Type of action. */
+          type: v.pipe(
+            v.literal("linkStakingUser"),
+            v.description("Type of action."),
+          ),
+          /** Chain ID used for signing. */
+          signatureChainId: v.pipe(
+            Hex,
+            v.description("Chain ID used for signing."),
+          ),
+          /** HyperLiquid network. */
+          hyperliquidChain: v.pipe(
+            v.union([v.literal("Mainnet"), v.literal("Testnet")]),
+            v.description("HyperLiquid network."),
+          ),
+          /**
+           * Target account address.
+           * - Trading user initiating: enter staking account address.
+           * - Staking user finalizing: enter trading account address.
+           */
+          user: v.pipe(
+            Address,
+            v.description(
+              "Target account address." +
+                "\n- Trading user initiating: enter staking account address." +
+                "\n- Staking user finalizing: enter trading account address.",
+            ),
+          ),
+          /**
+           * Link phase.
+           * - `false` = trading user initiates link request.
+           * - `true` = staking user finalizes permanent link.
+           */
+          isFinalize: v.pipe(
+            v.boolean(),
+            v.description(
+              "Link phase." +
+                "\n- `false` = trading user initiates link request." +
+                "\n- `true` = staking user finalizes permanent link.",
+            ),
+          ),
+          /** Unique request identifier (current timestamp in ms). */
+          nonce: v.pipe(
+            UnsignedInteger,
+            v.description("Unique request identifier (current timestamp in ms)."),
+          ),
+        }),
+        v.description("Action to perform."),
+      ),
+      /** Unique request identifier (current timestamp in ms). */
+      nonce: v.pipe(
+        UnsignedInteger,
+        v.description("Unique request identifier (current timestamp in ms)."),
+      ),
+      /** Cryptographic signature. */
+      signature: v.pipe(
+        Signature,
+        v.description("Cryptographic signature."),
+      ),
+    }),
+    v.description(""),
+  );
+})();
+export type LinkStakingUserRequest = v.InferOutput<typeof LinkStakingUserRequest>;
+
+import { SuccessResponse } from "./_base/mod.js";
+export { SuccessResponse };
+
+// -------------------- Function --------------------
+
+/** Action parameters for the {@linkcode linkStakingUser} function. */
+export type LinkStakingUserParameters = ExtractRequestAction<v.InferInput<typeof LinkStakingUserRequest>>;
+/** Request options for the {@linkcode linkStakingUser} function. */
+export type LinkStakingUserOptions = ExtractRequestOptions<v.InferInput<typeof LinkStakingUserRequest>>;
+
+/** EIP-712 types for the {@linkcode linkStakingUser} function. */
+export const LinkStakingUserTypes = {
+  "HyperliquidTransaction:LinkStakingUser": [
+    { name: "hyperliquidChain", type: "string" },
+    { name: "user", type: "address" },
+    { name: "isFinalize", type: "bool" },
+    { name: "nonce", type: "uint64" },
+  ],
+};
+
+/**
+ * Link staking and trading accounts for fee discount attribution.
+ * @param config - General configuration for Exchange API requests.
+ * @param params - Parameters specific to the API request.
+ * @param opts - Request execution options.
+ * @returns Successful response without specific data.
+ *
+ * @throws {ApiRequestError} When the API returns an unsuccessful response.
+ * @throws {TransportError} When the transport layer throws an error.
+ *
+ * @see https://hyperliquid.gitbook.io/hyperliquid-docs/trading/fees#staking-linking
+ * @example
+ * ```ts
+ * import { HttpTransport } from "@nktkas/hyperliquid";
+ * import { linkStakingUser } from "@nktkas/hyperliquid/api/exchange";
+ * import { privateKeyToAccount } from "npm:viem/accounts";
+ *
+ * const wallet = privateKeyToAccount("0x..."); // viem or ethers
+ * const transport = new HttpTransport(); // or `WebSocketTransport`
+ *
+ * await linkStakingUser(
+ *   { transport, wallet },
+ *   { user: "0x...", isFinalize: false },
+ * );
+ * ```
+ */
+export async function linkStakingUser(
+  config: ExchangeRequestConfig | MultiSignRequestConfig,
+  params: DeepImmutable<LinkStakingUserParameters>,
+  opts?: LinkStakingUserOptions,
+): Promise<SuccessResponse> {
+  const request = parser(LinkStakingUserRequest)({
+    action: {
+      type: "linkStakingUser",
+      hyperliquidChain: config.transport.isTestnet ? "Testnet" : "Mainnet",
+      signatureChainId: await getSignatureChainId(config),
+      nonce: 0, // Placeholder; actual nonce generated in `executeUserSignedAction` to prevent race conditions
+      ...params,
+    },
+    nonce: 0, // Placeholder; actual nonce generated in `executeUserSignedAction` to prevent race conditions
+    signature: { // Placeholder; actual signature generated in `executeUserSignedAction`
+      r: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      s: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      v: 27,
+    },
+  });
+  return await executeUserSignedAction(config, request, LinkStakingUserTypes, opts?.signal);
+}