@nktkas/hyperliquid 0.25.7 → 0.25.8

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);
+}

package/src/src/api/exchange/modify.ts

@@ -119,18 +119,21 @@ export async function modify(
   params: DeepImmutable<ModifyParameters>,
   opts?: ModifyOptions,
 ): Promise<SuccessResponse> {
-  const action = parser(ModifyRequest.entries.action)({
-    type: "modify",
-    ...params,
+  const request = parser(ModifyRequest)({
+    action: {
+      type: "modify",
+      ...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/multiSig.ts

@@ -282,28 +282,22 @@ export async function multiSig<
 ): Promise<T> {
   const { nonce, ...params } = paramsAndNonce;
 
-  const action = parser(MultiSigRequest.entries.action)({
-    type: "multiSig",
-    signatureChainId: await getSignatureChainId(config),
-    ...params,
-  });
-
-  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 executeMultiSigAction(
-    config,
-    {
-      action,
-      vaultAddress,
-      expiresAfter,
-      nonce: Number(nonce),
+  const request = parser(MultiSigRequest)({
+    action: {
+      type: "multiSig",
+      signatureChainId: await getSignatureChainId(config),
+      ...params,
     },
-    opts?.signal,
-  );
+    nonce,
+    signature: { // Placeholder; actual signature generated in `executeMultiSigAction`
+      r: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      s: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      v: 27,
+    },
+    vaultAddress: opts?.vaultAddress ?? config.defaultVaultAddress,
+    expiresAfter: typeof config.defaultExpiresAfter === "number"
+      ? config.defaultExpiresAfter
+      : await config.defaultExpiresAfter?.(),
+  });
+  return await executeMultiSigAction(config, request, opts?.signal);
 }

package/src/src/api/exchange/noop.ts

@@ -84,14 +84,19 @@ export async function noop(
   config: ExchangeRequestConfig | MultiSignRequestConfig,
   opts?: NoopOptions,
 ): Promise<SuccessResponse> {
-  const action = parser(NoopRequest.entries.action)({
-    type: "noop",
+  const request = parser(NoopRequest)({
+    action: {
+      type: "noop",
+    },
+    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/order.ts

@@ -330,18 +330,21 @@ export async function order(
   params: DeepImmutable<OrderParameters>,
   opts?: OrderOptions,
 ): Promise<OrderSuccessResponse> {
-  const action = parser(OrderRequest.entries.action)({
-    type: "order",
-    ...params,
+  const request = parser(OrderRequest)({
+    action: {
+      type: "order",
+      ...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/perpDeploy.ts

@@ -317,15 +317,20 @@ export async function perpDeploy(
   params: DeepImmutable<PerpDeployParameters>,
   opts?: PerpDeployOptions,
 ): Promise<SuccessResponse> {
-  const action = parser(PerpDeployRequest.entries.action)({
-    type: "perpDeploy",
-    ...params,
+  const request = parser(PerpDeployRequest)({
+    action: {
+      type: "perpDeploy",
+      ...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/registerReferrer.ts

@@ -97,15 +97,20 @@ export async function registerReferrer(
   params: DeepImmutable<RegisterReferrerParameters>,
   opts?: RegisterReferrerOptions,
 ): Promise<SuccessResponse> {
-  const action = parser(RegisterReferrerRequest.entries.action)({
-    type: "registerReferrer",
-    ...params,
+  const request = parser(RegisterReferrerRequest)({
+    action: {
+      type: "registerReferrer",
+      ...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/reserveRequestWeight.ts

@@ -96,15 +96,20 @@ export async function reserveRequestWeight(
   params: DeepImmutable<ReserveRequestWeightParameters>,
   opts?: ReserveRequestWeightOptions,
 ): Promise<SuccessResponse> {
-  const action = parser(ReserveRequestWeightRequest.entries.action)({
-    type: "reserveRequestWeight",
-    ...params,
+  const request = parser(ReserveRequestWeightRequest)({
+    action: {
+      type: "reserveRequestWeight",
+      ...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/scheduleCancel.ts

@@ -125,18 +125,21 @@ export async function scheduleCancel(
   const params = isFirstArgParams ? paramsOrOpts : {};
   const opts = isFirstArgParams ? maybeOpts : paramsOrOpts as ScheduleCancelOptions;
 
-  const action = parser(ScheduleCancelRequest.entries.action)({
-    type: "scheduleCancel",
-    ...params,
+  const request = parser(ScheduleCancelRequest)({
+    action: {
+      type: "scheduleCancel",
+      ...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/sendAsset.ts

@@ -6,7 +6,6 @@ import {
   type ExtractRequestAction,
   type ExtractRequestOptions,
   getSignatureChainId,
-  globalNonceManager,
   type MultiSignRequestConfig,
   Signature,
 } from "./_base/mod.js";
@@ -153,16 +152,20 @@ export async function sendAsset(
   params: DeepImmutable<SendAssetParameters>,
   opts?: SendAssetOptions,
 ): Promise<SuccessResponse> {
-  const action = parser(SendAssetRequest.entries.action)({
-    type: "sendAsset",
-    hyperliquidChain: config.transport.isTestnet ? "Testnet" : "Mainnet",
-    signatureChainId: await getSignatureChainId(config),
-    nonce: globalNonceManager.getNonce(),
-    ...params,
+  const request = parser(SendAssetRequest)({
+    action: {
+      type: "sendAsset",
+      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: SendAssetTypes },
-    opts?.signal,
-  );
+  return await executeUserSignedAction(config, request, SendAssetTypes, opts?.signal);
 }

package/src/src/api/exchange/setDisplayName.ts

@@ -103,15 +103,20 @@ export async function setDisplayName(
   params: DeepImmutable<SetDisplayNameParameters>,
   opts?: SetDisplayNameOptions,
 ): Promise<SuccessResponse> {
-  const action = parser(SetDisplayNameRequest.entries.action)({
-    type: "setDisplayName",
-    ...params,
+  const request = parser(SetDisplayNameRequest)({
+    action: {
+      type: "setDisplayName",
+      ...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);
 }