@nktkas/hyperliquid 0.32.1 → 0.32.2

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

@@ -71,16 +71,16 @@ import { parse } from "../../../_base.js";
 import type { ExcludeErrorResponse } from "./_base/errors.js";
 import { type ExchangeConfig, executeUserSignedAction, type ExtractRequestOptions } from "./_base/execute.js";
 
-/** Schema for user-provided action parameters (excludes system fields). */
-const ApproveAgentParameters = /* @__PURE__ */ (() => {
+/** Schema for action fields (excludes request-level system fields). */
+const ApproveAgentActionSchema = /* @__PURE__ */ (() => {
   return v.omit(
     v.object(ApproveAgentRequest.entries.action.entries),
-    ["type", "signatureChainId", "hyperliquidChain", "nonce"],
+    ["signatureChainId", "hyperliquidChain", "nonce"],
   );
 })();
 
 /** Action parameters for the {@linkcode approveAgent} function. */
-export type ApproveAgentParameters = v.InferInput<typeof ApproveAgentParameters>;
+export type ApproveAgentParameters = Omit<v.InferInput<typeof ApproveAgentActionSchema>, "type">;
 
 /** Request options for the {@linkcode approveAgent} function. */
 export type ApproveAgentOptions = ExtractRequestOptions<v.InferInput<typeof ApproveAgentRequest>>;
@@ -119,10 +119,10 @@ export const ApproveAgentTypes = {
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * await approveAgent(
- *   { transport, wallet },
- *   { agentAddress: "0x...", agentName: "myAgent" },
- * );
+ * await approveAgent({ transport, wallet }, {
+ *   agentAddress: "0x...",
+ *   agentName: "myAgent",
+ * });
  * ```
  *
  * @example With expiration timestamp
@@ -135,13 +135,10 @@ export const ApproveAgentTypes = {
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
  * const expirationTimestamp = Date.now() + 24 * 60 * 60 * 1000; // 24 hours from now
- * await approveAgent(
- *   { transport, wallet },
- *   {
- *     agentAddress: "0x...",
- *     agentName: `myAgent valid_until ${expirationTimestamp}`,
- *   },
- * );
+ * await approveAgent({ transport, wallet }, {
+ *   agentAddress: "0x...",
+ *   agentName: `myAgent valid_until ${expirationTimestamp}`,
+ * });
  * ```
  *
  * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#approve-an-api-wallet
@@ -151,11 +148,6 @@ export function approveAgent(
   params: ApproveAgentParameters,
   opts?: ApproveAgentOptions,
 ): Promise<ApproveAgentSuccessResponse> {
-  const action = parse(ApproveAgentParameters, params);
-  return executeUserSignedAction(
-    config,
-    { type: "approveAgent", ...action },
-    ApproveAgentTypes,
-    opts,
-  );
+  const action = parse(ApproveAgentActionSchema, { type: "approveAgent", ...params });
+  return executeUserSignedAction(config, action, ApproveAgentTypes, opts);
 }

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

@@ -55,16 +55,16 @@ import { parse } from "../../../_base.js";
 import type { ExcludeErrorResponse } from "./_base/errors.js";
 import { type ExchangeConfig, executeUserSignedAction, type ExtractRequestOptions } from "./_base/execute.js";
 
-/** Schema for user-provided action parameters (excludes system fields). */
-const ApproveBuilderFeeParameters = /* @__PURE__ */ (() => {
+/** Schema for action fields (excludes request-level system fields). */
+const ApproveBuilderFeeActionSchema = /* @__PURE__ */ (() => {
   return v.omit(
     v.object(ApproveBuilderFeeRequest.entries.action.entries),
-    ["type", "signatureChainId", "hyperliquidChain", "nonce"],
+    ["signatureChainId", "hyperliquidChain", "nonce"],
   );
 })();
 
 /** Action parameters for the {@linkcode approveBuilderFee} function. */
-export type ApproveBuilderFeeParameters = v.InferInput<typeof ApproveBuilderFeeParameters>;
+export type ApproveBuilderFeeParameters = Omit<v.InferInput<typeof ApproveBuilderFeeActionSchema>, "type">;
 
 /** Request options for the {@linkcode approveBuilderFee} function. */
 export type ApproveBuilderFeeOptions = ExtractRequestOptions<v.InferInput<typeof ApproveBuilderFeeRequest>>;
@@ -103,10 +103,10 @@ export const ApproveBuilderFeeTypes = {
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * await approveBuilderFee(
- *   { transport, wallet },
- *   { maxFeeRate: "0.01%", builder: "0x..." },
- * );
+ * await approveBuilderFee({ transport, wallet }, {
+ *   maxFeeRate: "0.01%",
+ *   builder: "0x...",
+ * });
  * ```
  *
  * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#approve-a-builder-fee
@@ -116,11 +116,6 @@ export function approveBuilderFee(
   params: ApproveBuilderFeeParameters,
   opts?: ApproveBuilderFeeOptions,
 ): Promise<ApproveBuilderFeeSuccessResponse> {
-  const action = parse(ApproveBuilderFeeParameters, params);
-  return executeUserSignedAction(
-    config,
-    { type: "approveBuilderFee", ...action },
-    ApproveBuilderFeeTypes,
-    opts,
-  );
+  const action = parse(ApproveBuilderFeeActionSchema, { type: "approveBuilderFee", ...params });
+  return executeUserSignedAction(config, action, ApproveBuilderFeeTypes, opts);
 }

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

@@ -100,16 +100,13 @@ import { parse } from "../../../_base.js";
 import type { ExcludeErrorResponse } from "./_base/errors.js";
 import { type ExchangeConfig, executeL1Action, type ExtractRequestOptions } from "./_base/execute.js";
 
-/** Schema for user-provided action parameters (excludes system fields). */
-const BatchModifyParameters = /* @__PURE__ */ (() => {
-  return v.omit(
-    v.object(BatchModifyRequest.entries.action.entries),
-    ["type"],
-  );
+/** Schema for action fields (excludes request-level system fields). */
+const BatchModifyActionSchema = /* @__PURE__ */ (() => {
+  return v.object(BatchModifyRequest.entries.action.entries);
 })();
 
 /** Action parameters for the {@linkcode batchModify} function. */
-export type BatchModifyParameters = v.InferInput<typeof BatchModifyParameters>;
+export type BatchModifyParameters = Omit<v.InferInput<typeof BatchModifyActionSchema>, "type">;
 
 /** Request options for the {@linkcode batchModify} function. */
 export type BatchModifyOptions = ExtractRequestOptions<v.InferInput<typeof BatchModifyRequest>>;
@@ -138,24 +135,21 @@ export type BatchModifySuccessResponse = ExcludeErrorResponse<BatchModifyRespons
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * const data = await batchModify(
- *   { transport, wallet },
- *   {
- *     modifies: [
- *       {
- *         oid: 123,
- *         order: {
- *           a: 0,
- *           b: true,
- *           p: "31000",
- *           s: "0.2",
- *           r: false,
- *           t: { limit: { tif: "Gtc" } },
- *         },
+ * const data = await batchModify({ transport, wallet }, {
+ *   modifies: [
+ *     {
+ *       oid: 123,
+ *       order: {
+ *         a: 0,
+ *         b: true,
+ *         p: "31000",
+ *         s: "0.2",
+ *         r: false,
+ *         t: { limit: { tif: "Gtc" } },
  *       },
- *     ],
- *   },
- * );
+ *     },
+ *   ],
+ * });
  * ```
  *
  * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#modify-multiple-orders
@@ -165,6 +159,6 @@ export function batchModify(
   params: BatchModifyParameters,
   opts?: BatchModifyOptions,
 ): Promise<BatchModifySuccessResponse> {
-  const action = parse(BatchModifyParameters, params);
-  return executeL1Action(config, { type: "batchModify", ...action }, opts);
+  const action = parse(BatchModifyActionSchema, { type: "batchModify", ...params });
+  return executeL1Action(config, action, opts);
 }

package/src/api/exchange/_methods/borrowLend.ts

@@ -50,16 +50,13 @@ import { parse } from "../../../_base.js";
 import type { ExcludeErrorResponse } from "./_base/errors.js";
 import { type ExchangeConfig, executeL1Action, type ExtractRequestOptions } from "./_base/execute.js";
 
-/** Schema for user-provided action parameters (excludes system fields). */
-const BorrowLendParameters = /* @__PURE__ */ (() => {
-  return v.omit(
-    v.object(BorrowLendRequest.entries.action.entries),
-    ["type"],
-  );
+/** Schema for action fields (excludes request-level system fields). */
+const BorrowLendActionSchema = /* @__PURE__ */ (() => {
+  return v.object(BorrowLendRequest.entries.action.entries);
 })();
 
 /** Action parameters for the {@linkcode borrowLend} function. */
-export type BorrowLendParameters = v.InferInput<typeof BorrowLendParameters>;
+export type BorrowLendParameters = Omit<v.InferInput<typeof BorrowLendActionSchema>, "type">;
 
 /** Request options for the {@linkcode borrowLend} function. */
 export type BorrowLendOptions = ExtractRequestOptions<v.InferInput<typeof BorrowLendRequest>>;
@@ -88,10 +85,11 @@ export type BorrowLendSuccessResponse = ExcludeErrorResponse<BorrowLendResponse>
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * await borrowLend(
- *   { transport, wallet },
- *   { operation: "supply", token: 0, amount: "20" },
- * );
+ * await borrowLend({ transport, wallet }, {
+ *   operation: "supply",
+ *   token: 0,
+ *   amount: "20",
+ * });
  * ```
  *
  * @see null
@@ -101,6 +99,6 @@ export function borrowLend(
   params: BorrowLendParameters,
   opts?: BorrowLendOptions,
 ): Promise<BorrowLendSuccessResponse> {
-  const action = parse(BorrowLendParameters, params);
-  return executeL1Action(config, { type: "borrowLend", ...action }, opts);
+  const action = parse(BorrowLendActionSchema, { type: "borrowLend", ...params });
+  return executeL1Action(config, action, opts);
 }

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

@@ -53,16 +53,16 @@ import { parse } from "../../../_base.js";
 import type { ExcludeErrorResponse } from "./_base/errors.js";
 import { type ExchangeConfig, executeUserSignedAction, type ExtractRequestOptions } from "./_base/execute.js";
 
-/** Schema for user-provided action parameters (excludes system fields). */
-const CDepositParameters = /* @__PURE__ */ (() => {
+/** Schema for action fields (excludes request-level system fields). */
+const CDepositActionSchema = /* @__PURE__ */ (() => {
   return v.omit(
     v.object(CDepositRequest.entries.action.entries),
-    ["type", "signatureChainId", "hyperliquidChain", "nonce"],
+    ["signatureChainId", "hyperliquidChain", "nonce"],
   );
 })();
 
 /** Action parameters for the {@linkcode cDeposit} function. */
-export type CDepositParameters = v.InferInput<typeof CDepositParameters>;
+export type CDepositParameters = Omit<v.InferInput<typeof CDepositActionSchema>, "type">;
 
 /** Request options for the {@linkcode cDeposit} function. */
 export type CDepositOptions = ExtractRequestOptions<v.InferInput<typeof CDepositRequest>>;
@@ -100,10 +100,9 @@ export const CDepositTypes = {
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * await cDeposit(
- *   { transport, wallet },
- *   { wei: 1 * 1e8 },
- * );
+ * await cDeposit({ transport, wallet }, {
+ *   wei: 1 * 1e8,
+ * });
  * ```
  *
  * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#deposit-into-staking
@@ -113,11 +112,6 @@ export function cDeposit(
   params: CDepositParameters,
   opts?: CDepositOptions,
 ): Promise<CDepositSuccessResponse> {
-  const action = parse(CDepositParameters, params);
-  return executeUserSignedAction(
-    config,
-    { type: "cDeposit", ...action },
-    CDepositTypes,
-    opts,
-  );
+  const action = parse(CDepositActionSchema, { type: "cDeposit", ...params });
+  return executeUserSignedAction(config, action, CDepositTypes, opts);
 }

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

@@ -52,15 +52,15 @@ import { parse } from "../../../_base.js";
 import type { ExcludeErrorResponse } from "./_base/errors.js";
 import { type ExchangeConfig, executeL1Action, type ExtractRequestOptions } from "./_base/execute.js";
 
-/** Schema for user-provided action parameters (excludes system fields). */
-const CSignerActionParameters = /* @__PURE__ */ (() => {
-  return v.union(
-    CSignerActionRequest.entries.action.options.map((option) => v.omit(option, ["type"])),
-  );
+/** Schema for action fields (excludes request-level system fields). */
+const CSignerActionActionSchema = /* @__PURE__ */ (() => {
+  return v.variant("type", CSignerActionRequest.entries.action.options);
 })();
 
 /** Action parameters for the {@linkcode cSignerAction} function. */
-export type CSignerActionParameters = v.InferInput<typeof CSignerActionParameters>;
+export type CSignerActionParameters = v.InferInput<typeof CSignerActionActionSchema> extends infer T
+  ? T extends unknown ? { [K in Exclude<keyof T, "type">]: T[K] } : never
+  : never;
 
 /** Request options for the {@linkcode cSignerAction} function. */
 export type CSignerActionOptions = ExtractRequestOptions<v.InferInput<typeof CSignerActionRequest>>;
@@ -89,10 +89,9 @@ export type CSignerActionSuccessResponse = ExcludeErrorResponse<CSignerActionRes
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * await cSignerAction(
- *   { transport, wallet },
- *   { jailSelf: null },
- * );
+ * await cSignerAction({ transport, wallet }, {
+ *   jailSelf: null,
+ * });
  * ```
  *
  * @example Unjail self
@@ -104,10 +103,9 @@ export type CSignerActionSuccessResponse = ExcludeErrorResponse<CSignerActionRes
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * await cSignerAction(
- *   { transport, wallet },
- *   { unjailSelf: null },
- * );
+ * await cSignerAction({ transport, wallet }, {
+ *   unjailSelf: null,
+ * });
  * ```
  *
  * @see null
@@ -117,6 +115,6 @@ export function cSignerAction(
   params: CSignerActionParameters,
   opts?: CSignerActionOptions,
 ): Promise<CSignerActionSuccessResponse> {
-  const action = parse(CSignerActionParameters, params);
-  return executeL1Action(config, { type: "CSignerAction", ...action }, opts);
+  const action = parse(CSignerActionActionSchema, { type: "CSignerAction", ...params });
+  return executeL1Action(config, action, opts);
 }

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

@@ -101,15 +101,15 @@ import { parse } from "../../../_base.js";
 import type { ExcludeErrorResponse } from "./_base/errors.js";
 import { type ExchangeConfig, executeL1Action, type ExtractRequestOptions } from "./_base/execute.js";
 
-/** Schema for user-provided action parameters (excludes system fields). */
-const CValidatorActionParameters = /* @__PURE__ */ (() => {
-  return v.union(
-    CValidatorActionRequest.entries.action.options.map((option) => v.omit(option, ["type"])),
-  );
+/** Schema for action fields (excludes request-level system fields). */
+const CValidatorActionActionSchema = /* @__PURE__ */ (() => {
+  return v.variant("type", CValidatorActionRequest.entries.action.options);
 })();
 
 /** Action parameters for the {@linkcode cValidatorAction} function. */
-export type CValidatorActionParameters = v.InferInput<typeof CValidatorActionParameters>;
+export type CValidatorActionParameters = v.InferInput<typeof CValidatorActionActionSchema> extends infer T
+  ? T extends unknown ? { [K in Exclude<keyof T, "type">]: T[K] } : never
+  : never;
 
 /** Request options for the {@linkcode cValidatorAction} function. */
 export type CValidatorActionOptions = ExtractRequestOptions<v.InferInput<typeof CValidatorActionRequest>>;
@@ -138,20 +138,17 @@ export type CValidatorActionSuccessResponse = ExcludeErrorResponse<CValidatorAct
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * await cValidatorAction(
- *   { transport, wallet },
- *   {
- *     changeProfile: {
- *       node_ip: { Ip: "1.2.3.4" },
- *       name: "...",
- *       description: "...",
- *       unjailed: true,
- *       disable_delegations: false,
- *       commission_bps: null,
- *       signer: null,
- *     },
+ * await cValidatorAction({ transport, wallet }, {
+ *   changeProfile: {
+ *     node_ip: { Ip: "1.2.3.4" },
+ *     name: "...",
+ *     description: "...",
+ *     unjailed: true,
+ *     disable_delegations: false,
+ *     commission_bps: null,
+ *     signer: null,
  *   },
- * );
+ * });
  * ```
  *
  * @see null
@@ -161,6 +158,6 @@ export function cValidatorAction(
   params: CValidatorActionParameters,
   opts?: CValidatorActionOptions,
 ): Promise<CValidatorActionSuccessResponse> {
-  const action = parse(CValidatorActionParameters, params);
-  return executeL1Action(config, { type: "CValidatorAction", ...action }, opts);
+  const action = parse(CValidatorActionActionSchema, { type: "CValidatorAction", ...params });
+  return executeL1Action(config, action, opts);
 }

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

@@ -53,16 +53,16 @@ import { parse } from "../../../_base.js";
 import type { ExcludeErrorResponse } from "./_base/errors.js";
 import { type ExchangeConfig, executeUserSignedAction, type ExtractRequestOptions } from "./_base/execute.js";
 
-/** Schema for user-provided action parameters (excludes system fields). */
-const CWithdrawParameters = /* @__PURE__ */ (() => {
+/** Schema for action fields (excludes request-level system fields). */
+const CWithdrawActionSchema = /* @__PURE__ */ (() => {
   return v.omit(
     v.object(CWithdrawRequest.entries.action.entries),
-    ["type", "signatureChainId", "hyperliquidChain", "nonce"],
+    ["signatureChainId", "hyperliquidChain", "nonce"],
   );
 })();
 
 /** Action parameters for the {@linkcode cWithdraw} function. */
-export type CWithdrawParameters = v.InferInput<typeof CWithdrawParameters>;
+export type CWithdrawParameters = Omit<v.InferInput<typeof CWithdrawActionSchema>, "type">;
 
 /** Request options for the {@linkcode cWithdraw} function. */
 export type CWithdrawOptions = ExtractRequestOptions<v.InferInput<typeof CWithdrawRequest>>;
@@ -100,10 +100,9 @@ export const CWithdrawTypes = {
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * await cWithdraw(
- *   { transport, wallet },
- *   { wei: 1 * 1e8 },
- * );
+ * await cWithdraw({ transport, wallet }, {
+ *   wei: 1 * 1e8,
+ * });
  * ```
  *
  * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#withdraw-from-staking
@@ -113,11 +112,6 @@ export function cWithdraw(
   params: CWithdrawParameters,
   opts?: CWithdrawOptions,
 ): Promise<CWithdrawSuccessResponse> {
-  const action = parse(CWithdrawParameters, params);
-  return executeUserSignedAction(
-    config,
-    { type: "cWithdraw", ...action },
-    CWithdrawTypes,
-    opts,
-  );
+  const action = parse(CWithdrawActionSchema, { type: "cWithdraw", ...params });
+  return executeUserSignedAction(config, action, CWithdrawTypes, opts);
 }

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

@@ -69,16 +69,13 @@ import { parse } from "../../../_base.js";
 import type { ExcludeErrorResponse } from "./_base/errors.js";
 import { type ExchangeConfig, executeL1Action, type ExtractRequestOptions } from "./_base/execute.js";
 
-/** Schema for user-provided action parameters (excludes system fields). */
-const CancelParameters = /* @__PURE__ */ (() => {
-  return v.omit(
-    v.object(CancelRequest.entries.action.entries),
-    ["type"],
-  );
+/** Schema for action fields (excludes request-level system fields). */
+const CancelActionSchema = /* @__PURE__ */ (() => {
+  return v.object(CancelRequest.entries.action.entries);
 })();
 
 /** Action parameters for the {@linkcode cancel} function. */
-export type CancelParameters = v.InferInput<typeof CancelParameters>;
+export type CancelParameters = Omit<v.InferInput<typeof CancelActionSchema>, "type">;
 
 /** Request options for the {@linkcode cancel} function. */
 export type CancelOptions = ExtractRequestOptions<v.InferInput<typeof CancelRequest>>;
@@ -107,10 +104,9 @@ export type CancelSuccessResponse = ExcludeErrorResponse<CancelResponse>;
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * await cancel(
- *   { transport, wallet },
- *   { cancels: [{ a: 0, o: 123 }] },
- * );
+ * await cancel({ transport, wallet }, {
+ *   cancels: [{ a: 0, o: 123 }],
+ * });
  * ```
  *
  * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#cancel-order-s
@@ -120,6 +116,6 @@ export function cancel(
   params: CancelParameters,
   opts?: CancelOptions,
 ): Promise<CancelSuccessResponse> {
-  const action = parse(CancelParameters, params);
-  return executeL1Action(config, { type: "cancel", ...action }, opts);
+  const action = parse(CancelActionSchema, { type: "cancel", ...params });
+  return executeL1Action(config, action, opts);
 }

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

@@ -54,16 +54,13 @@ import { parse } from "../../../_base.js";
 import type { ExcludeErrorResponse } from "./_base/errors.js";
 import { type ExchangeConfig, executeL1Action, type ExtractRequestOptions } from "./_base/execute.js";
 
-/** Schema for user-provided action parameters (excludes system fields). */
-const CancelByCloidParameters = /* @__PURE__ */ (() => {
-  return v.omit(
-    v.object(CancelByCloidRequest.entries.action.entries),
-    ["type"],
-  );
+/** Schema for action fields (excludes request-level system fields). */
+const CancelByCloidActionSchema = /* @__PURE__ */ (() => {
+  return v.object(CancelByCloidRequest.entries.action.entries);
 })();
 
 /** Action parameters for the {@linkcode cancelByCloid} function. */
-export type CancelByCloidParameters = v.InferInput<typeof CancelByCloidParameters>;
+export type CancelByCloidParameters = Omit<v.InferInput<typeof CancelByCloidActionSchema>, "type">;
 
 /** Request options for the {@linkcode cancelByCloid} function. */
 export type CancelByCloidOptions = ExtractRequestOptions<v.InferInput<typeof CancelByCloidRequest>>;
@@ -92,14 +89,11 @@ export type CancelByCloidSuccessResponse = ExcludeErrorResponse<CancelByCloidRes
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * await cancelByCloid(
- *   { transport, wallet },
- *   {
- *     cancels: [
- *       { asset: 0, cloid: "0x..." },
- *     ],
- *   },
- * );
+ * await cancelByCloid({ transport, wallet }, {
+ *   cancels: [
+ *     { asset: 0, cloid: "0x..." },
+ *   ],
+ * });
  * ```
  *
  * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#cancel-order-s-by-cloid
@@ -109,6 +103,6 @@ export function cancelByCloid(
   params: CancelByCloidParameters,
   opts?: CancelByCloidOptions,
 ): Promise<CancelByCloidSuccessResponse> {
-  const action = parse(CancelByCloidParameters, params);
-  return executeL1Action(config, { type: "cancelByCloid", ...action }, opts);
+  const action = parse(CancelByCloidActionSchema, { type: "cancelByCloid", ...params });
+  return executeL1Action(config, action, opts);
 }

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

@@ -38,9 +38,15 @@ export type ClaimRewardsResponse = SuccessResponse | ErrorResponse;
 // Execution Logic
 // ============================================================
 
+import { parse } from "../../../_base.js";
 import type { ExcludeErrorResponse } from "./_base/errors.js";
 import { type ExchangeConfig, executeL1Action, type ExtractRequestOptions } from "./_base/execute.js";
 
+/** Schema for action fields (excludes request-level system fields). */
+const ClaimRewardsActionSchema = /* @__PURE__ */ (() => {
+  return v.object(ClaimRewardsRequest.entries.action.entries);
+})();
+
 /** Request options for the {@linkcode claimRewards} function. */
 export type ClaimRewardsOptions = ExtractRequestOptions<v.InferInput<typeof ClaimRewardsRequest>>;
 
@@ -76,5 +82,6 @@ export function claimRewards(
   config: ExchangeConfig,
   opts?: ClaimRewardsOptions,
 ): Promise<ClaimRewardsSuccessResponse> {
-  return executeL1Action(config, { type: "claimRewards" }, opts);
+  const action = parse(ClaimRewardsActionSchema, { type: "claimRewards" });
+  return executeL1Action(config, action, opts);
 }

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

@@ -81,16 +81,16 @@ import { parse } from "../../../_base.js";
 import type { ExcludeErrorResponse } from "./_base/errors.js";
 import { type ExchangeConfig, executeUserSignedAction, type ExtractRequestOptions } from "./_base/execute.js";
 
-/** Schema for user-provided action parameters (excludes system fields). */
-const ConvertToMultiSigUserParameters = /* @__PURE__ */ (() => {
+/** Schema for action fields (excludes request-level system fields). */
+const ConvertToMultiSigUserActionSchema = /* @__PURE__ */ (() => {
   return v.omit(
     v.object(ConvertToMultiSigUserRequest.entries.action.entries),
-    ["type", "signatureChainId", "hyperliquidChain", "nonce"],
+    ["signatureChainId", "hyperliquidChain", "nonce"],
   );
 })();
 
 /** Action parameters for the {@linkcode convertToMultiSigUser} function. */
-export type ConvertToMultiSigUserParameters = v.InferInput<typeof ConvertToMultiSigUserParameters>;
+export type ConvertToMultiSigUserParameters = Omit<v.InferInput<typeof ConvertToMultiSigUserActionSchema>, "type">;
 
 /** Request options for the {@linkcode convertToMultiSigUser} function. */
 export type ConvertToMultiSigUserOptions = ExtractRequestOptions<v.InferInput<typeof ConvertToMultiSigUserRequest>>;
@@ -128,15 +128,12 @@ export const ConvertToMultiSigUserTypes = {
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * await convertToMultiSigUser(
- *   { transport, wallet },
- *   {
- *     signers: {
- *       authorizedUsers: ["0x...", "0x...", "0x..."],
- *       threshold: 2,
- *     },
+ * await convertToMultiSigUser({ transport, wallet }, {
+ *   signers: {
+ *     authorizedUsers: ["0x...", "0x...", "0x..."],
+ *     threshold: 2,
  *   },
- * );
+ * });
  * ```
  *
  * @example Convert to single-sig user
@@ -148,10 +145,9 @@ export const ConvertToMultiSigUserTypes = {
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * await convertToMultiSigUser(
- *   { transport, wallet },
- *   { signers: null },
- * );
+ * await convertToMultiSigUser({ transport, wallet }, {
+ *   signers: null,
+ * });
  * ```
  *
  * @see https://hyperliquid.gitbook.io/hyperliquid-docs/hypercore/multi-sig
@@ -161,11 +157,6 @@ export function convertToMultiSigUser(
   params: ConvertToMultiSigUserParameters,
   opts?: ConvertToMultiSigUserOptions,
 ): Promise<ConvertToMultiSigUserSuccessResponse> {
-  const action = parse(ConvertToMultiSigUserParameters, params);
-  return executeUserSignedAction(
-    config,
-    { type: "convertToMultiSigUser", ...action },
-    ConvertToMultiSigUserTypes,
-    opts,
-  );
+  const action = parse(ConvertToMultiSigUserActionSchema, { type: "convertToMultiSigUser", ...params });
+  return executeUserSignedAction(config, action, ConvertToMultiSigUserTypes, opts);
 }