@nktkas/hyperliquid 0.25.6 → 0.25.8

package/src/src/api/exchange/_base/_execute.ts

@@ -1,9 +1,9 @@
+import { getSemaphore } from "@henrygd/semaphore";
 import { getWalletAddress, signL1Action, signMultiSigAction, signUserSignedAction } from "../../../signing/mod.js";
 import { assertSuccessResponse } from "./_errors.js";
 import type { AnyResponse, AnySuccessResponse, ExchangeRequestConfig, MultiSignRequestConfig } from "./_types.js";
 import { globalNonceManager } from "./_nonce.js";
 import { getSignatureChainId } from "./_helpers.js";
-import { getRequestQueue } from "./_sequential.js";
 
 export async function executeL1Action<T extends AnySuccessResponse>(
   config: ExchangeRequestConfig | MultiSignRequestConfig,
@@ -14,15 +14,26 @@ export async function executeL1Action<T extends AnySuccessResponse>(
   },
   signal?: AbortSignal,
 ): Promise<T> {
-  const fn = async (): Promise<T> => {
-    const { transport } = config;
-    const { action, vaultAddress, expiresAfter } = request;
+  const { transport } = config;
+  const { action, vaultAddress, expiresAfter } = request;
 
+  // Sequential request execution to prevent nonce race conditions at the network layer
+  const walletAddress = "signers" in config
+    ? await getWalletAddress(config.signers[0])
+    : await getWalletAddress(config.wallet);
+  const walletKey = `@nktkas/hyperliquid:${walletAddress}:${config.transport.isTestnet}`;
+
+  const sem = getSemaphore(walletKey);
+  await sem.acquire();
+
+  // Main logic
+  try {
     const nonce = globalNonceManager.getNonce();
 
+    // Multi-signature request
     if ("signers" in config) {
       const { signers, multiSigUser } = config;
-      const outerSigner = await getWalletAddress(signers[0]);
+      const outerSigner = walletAddress;
 
       // Sign an L1 action for each signer
       const signatures = await Promise.all(signers.map(async (signer) => {
@@ -41,12 +52,7 @@ export async function executeL1Action<T extends AnySuccessResponse>(
 
       // Send a request via multi-sign action
       return await executeMultiSigAction(
-        {
-          ...config,
-          wallet: signers[0],
-          // Disable queue since we're already inside the queue
-          sequentialRequests: false,
-        },
+        { ...config, wallet: signers[0] },
         {
           action: {
             type: "multiSig",
@@ -59,8 +65,9 @@ export async function executeL1Action<T extends AnySuccessResponse>(
           nonce,
         },
         signal,
+        false,
       );
-    } else {
+    } else { // Single-signature request
       const { wallet } = config;
 
       // Sign an L1 action
@@ -82,11 +89,10 @@ export async function executeL1Action<T extends AnySuccessResponse>(
       assertSuccessResponse(response);
       return response as T;
     }
-  };
-
-  // Execute with queue if enabled, otherwise execute directly
-  const queue = await getRequestQueue(config);
-  return queue ? await queue.enqueue(fn) : await fn();
+  } finally {
+    // Release semaphore
+    sem.release();
+  }
 }
 
 export async function executeUserSignedAction<T extends AnySuccessResponse>(
@@ -101,24 +107,37 @@ export async function executeUserSignedAction<T extends AnySuccessResponse>(
         | { nonce: number; time?: undefined }
         | { time: number; nonce?: undefined }
       );
-    types: {
-      [key: string]: {
-        name: string;
-        type: string;
-      }[];
-    };
+  },
+  types: {
+    [key: string]: {
+      name: string;
+      type: string;
+    }[];
   },
   signal?: AbortSignal,
 ): Promise<T> {
-  const fn = async (): Promise<T> => {
-    const { transport } = config;
-    const { action, types } = request;
+  const { transport } = config;
+  const { action } = request;
+
+  // Sequential request execution to prevent nonce race conditions at the network layer
+  const walletAddress = "signers" in config
+    ? await getWalletAddress(config.signers[0])
+    : await getWalletAddress(config.wallet);
+  const walletKey = `@nktkas/hyperliquid:${walletAddress}:${config.transport.isTestnet}`;
 
-    const nonce = action.nonce ?? action.time;
+  const sem = getSemaphore(walletKey);
+  await sem.acquire();
 
+  // Main logic
+  try {
+    const nonce = globalNonceManager.getNonce();
+    if ("time" in action) request.action.time = nonce;
+    if ("nonce" in action) request.action.nonce = nonce;
+
+    // Multi-signature request
     if ("signers" in config) {
       const { signers, multiSigUser } = config;
-      const outerSigner = await getWalletAddress(signers[0]);
+      const outerSigner = walletAddress;
 
       // Sign a user-signed action for each signer
       const signatures = await Promise.all(signers.map(async (signer) => {
@@ -138,12 +157,7 @@ export async function executeUserSignedAction<T extends AnySuccessResponse>(
 
       // Send a request via multi-sign action
       return await executeMultiSigAction(
-        {
-          ...config,
-          wallet: signers[0],
-          // Disable queue since we're already inside the queue
-          sequentialRequests: false,
-        },
+        { ...config, wallet: signers[0] },
         {
           action: {
             type: "multiSig",
@@ -154,8 +168,9 @@ export async function executeUserSignedAction<T extends AnySuccessResponse>(
           nonce,
         },
         signal,
+        false,
       );
-    } else {
+    } else { // Single-signature request
       const { wallet } = config;
 
       // Sign a user-signed action
@@ -170,11 +185,10 @@ export async function executeUserSignedAction<T extends AnySuccessResponse>(
       assertSuccessResponse(response);
       return response as T;
     }
-  };
-
-  // Execute with queue if enabled, otherwise execute directly
-  const queue = await getRequestQueue(config);
-  return queue ? await queue.enqueue(fn) : await fn();
+  } finally {
+    // Release semaphore and nonce manager
+    sem.release();
+  }
 }
 
 export async function executeMultiSigAction<T extends AnySuccessResponse>(
@@ -189,11 +203,22 @@ export async function executeMultiSigAction<T extends AnySuccessResponse>(
     expiresAfter?: number;
   },
   signal?: AbortSignal,
+  semaphore = true,
 ): Promise<T> {
-  const fn = async (): Promise<T> => {
-    const { transport, wallet } = config;
-    const { action, nonce, vaultAddress, expiresAfter } = request;
-
+  const { transport, wallet } = config;
+  const { action, nonce, vaultAddress, expiresAfter } = request;
+
+  // Sequential request execution to prevent nonce race conditions at the network layer
+  let sem: ReturnType<typeof getSemaphore> | undefined;
+  if (semaphore) {
+    const walletAddress = await getWalletAddress(config.wallet);
+    const walletKey = `@nktkas/hyperliquid:${walletAddress}:${config.transport.isTestnet}`;
+    sem = getSemaphore(walletKey);
+    await sem.acquire();
+  }
+
+  // Main logic
+  try {
     // Sign a multi-signature action
     const signature = await signMultiSigAction({
       wallet,
@@ -212,9 +237,8 @@ export async function executeMultiSigAction<T extends AnySuccessResponse>(
     ) as AnyResponse;
     assertSuccessResponse(response);
     return response as T;
-  };
-
-  // Execute with queue if enabled, otherwise execute directly
-  const queue = await getRequestQueue(config);
-  return queue ? await queue.enqueue(fn) : await fn();
+  } finally {
+    // Release semaphore if used
+    sem?.release();
+  }
 }

package/src/src/api/exchange/_base/_types.ts

@@ -54,13 +54,6 @@ export interface ExchangeRequestConfig<
    * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#expires-after
    */
   defaultExpiresAfter?: number | (() => MaybePromise<number>);
-  /**
-   * Execute requests sequentially to prevent network-level race conditions.
-   * When enabled, requests are queued and executed one by one in order,
-   * ensuring they arrive at the server in the correct sequence.
-   * @default true
-   */
-  sequentialRequests?: boolean;
 }
 
 /** Configuration for Exchange API requests using multi-signature wallets. */

package/src/src/api/exchange/_base/mod.ts

@@ -1,7 +1,5 @@
 export * from "./_errors.js";
 export * from "./_execute.js";
 export * from "./_helpers.js";
-export * from "./_nonce.js";
-export * from "./_sequential.js";
 export * from "./_schemas.js";
 export * from "./_types.js";

package/src/src/api/exchange/agentEnableDexAbstraction.ts

@@ -86,14 +86,19 @@ export async function agentEnableDexAbstraction(
   config: ExchangeRequestConfig | MultiSignRequestConfig,
   opts?: AgentEnableDexAbstractionOptions,
 ): Promise<SuccessResponse> {
-  const action = parser(AgentEnableDexAbstractionRequest.entries.action)({
-    type: "agentEnableDexAbstraction",
+  const request = parser(AgentEnableDexAbstractionRequest)({
+    action: {
+      type: "agentEnableDexAbstraction",
+    },
+    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/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);
 }