@nktkas/hyperliquid 0.32.0 → 0.32.2

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

@@ -189,6 +189,23 @@ export const PerpDeployRequest = /* @__PURE__ */ (() => {
         /** A list (sorted by key) of asset and growth modes. */
         setGrowthModes: v.array(v.tuple([v.string(), v.boolean()])),
       }),
+      v.object({
+        /** Type of action. */
+        type: v.literal("perpDeploy"),
+        /** Parameters for setting a perp annotation. */
+        setPerpAnnotation: v.object({
+          /** Coin symbol for the asset to annotate. */
+          coin: v.string(),
+          /** Classification label (max 15 characters). */
+          category: v.string(),
+          /** Detailed description (max 400 characters). */
+          description: v.string(),
+          /** Display name for frontends to use instead of the L1 name, or null to ignore. */
+          displayName: v.nullable(v.string()),
+          /** Keywords used as hints to match against searches. */
+          keywords: v.array(v.string()),
+        }),
+      }),
     ]),
     /** Nonce (timestamp in ms) used to prevent replay attacks. */
     nonce: UnsignedInteger,
@@ -214,15 +231,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 PerpDeployParameters = /* @__PURE__ */ (() => {
-  return v.union(
-    PerpDeployRequest.entries.action.options.map((option) => v.omit(option, ["type"])),
-  );
+/** Schema for action fields (excludes request-level system fields). */
+const PerpDeployActionSchema = /* @__PURE__ */ (() => {
+  return v.variant("type", PerpDeployRequest.entries.action.options);
 })();
 
 /** Action parameters for the {@linkcode perpDeploy} function. */
-export type PerpDeployParameters = v.InferInput<typeof PerpDeployParameters>;
+export type PerpDeployParameters = v.InferInput<typeof PerpDeployActionSchema> extends infer T
+  ? T extends unknown ? { [K in Exclude<keyof T, "type">]: T[K] } : never
+  : never;
 
 /** Request options for the {@linkcode perpDeploy} function. */
 export type PerpDeployOptions = ExtractRequestOptions<v.InferInput<typeof PerpDeployRequest>>;
@@ -251,23 +268,20 @@ export type PerpDeploySuccessResponse = ExcludeErrorResponse<PerpDeployResponse>
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * await perpDeploy(
- *   { transport, wallet },
- *   {
- *     registerAsset: {
- *       maxGas: 1000000,
- *       assetRequest: {
- *         coin: "USDC",
- *         szDecimals: 8,
- *         oraclePx: "1",
- *         marginTableId: 1,
- *         onlyIsolated: false,
- *       },
- *       dex: "test",
- *       schema: null,
+ * await perpDeploy({ transport, wallet }, {
+ *   registerAsset: {
+ *     maxGas: 1000000,
+ *     assetRequest: {
+ *       coin: "USDC",
+ *       szDecimals: 8,
+ *       oraclePx: "1",
+ *       marginTableId: 1,
+ *       onlyIsolated: false,
  *     },
+ *     dex: "test",
+ *     schema: null,
  *   },
- * );
+ * });
  * ```
  *
  * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/hip-3-deployer-actions
@@ -277,6 +291,6 @@ export function perpDeploy(
   params: PerpDeployParameters,
   opts?: PerpDeployOptions,
 ): Promise<PerpDeploySuccessResponse> {
-  const action = parse(PerpDeployParameters, params);
-  return executeL1Action(config, { type: "perpDeploy", ...action }, opts);
+  const action = parse(PerpDeployActionSchema, { type: "perpDeploy", ...params });
+  return executeL1Action(config, action, opts);
 }

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

@@ -44,16 +44,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 RegisterReferrerParameters = /* @__PURE__ */ (() => {
-  return v.omit(
-    v.object(RegisterReferrerRequest.entries.action.entries),
-    ["type"],
-  );
+/** Schema for action fields (excludes request-level system fields). */
+const RegisterReferrerActionSchema = /* @__PURE__ */ (() => {
+  return v.object(RegisterReferrerRequest.entries.action.entries);
 })();
 
 /** Action parameters for the {@linkcode registerReferrer} function. */
-export type RegisterReferrerParameters = v.InferInput<typeof RegisterReferrerParameters>;
+export type RegisterReferrerParameters = Omit<v.InferInput<typeof RegisterReferrerActionSchema>, "type">;
 
 /** Request options for the {@linkcode registerReferrer} function. */
 export type RegisterReferrerOptions = ExtractRequestOptions<v.InferInput<typeof RegisterReferrerRequest>>;
@@ -82,10 +79,9 @@ export type RegisterReferrerSuccessResponse = ExcludeErrorResponse<RegisterRefer
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * await registerReferrer(
- *   { transport, wallet },
- *   { code: "..." },
- * );
+ * await registerReferrer({ transport, wallet }, {
+ *   code: "...",
+ * });
  * ```
  *
  * @see null
@@ -95,6 +91,6 @@ export function registerReferrer(
   params: RegisterReferrerParameters,
   opts?: RegisterReferrerOptions,
 ): Promise<RegisterReferrerSuccessResponse> {
-  const action = parse(RegisterReferrerParameters, params);
-  return executeL1Action(config, { type: "registerReferrer", ...action }, opts);
+  const action = parse(RegisterReferrerActionSchema, { type: "registerReferrer", ...params });
+  return executeL1Action(config, action, opts);
 }

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

@@ -44,16 +44,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 ReserveRequestWeightParameters = /* @__PURE__ */ (() => {
-  return v.omit(
-    v.object(ReserveRequestWeightRequest.entries.action.entries),
-    ["type"],
-  );
+/** Schema for action fields (excludes request-level system fields). */
+const ReserveRequestWeightActionSchema = /* @__PURE__ */ (() => {
+  return v.object(ReserveRequestWeightRequest.entries.action.entries);
 })();
 
 /** Action parameters for the {@linkcode reserveRequestWeight} function. */
-export type ReserveRequestWeightParameters = v.InferInput<typeof ReserveRequestWeightParameters>;
+export type ReserveRequestWeightParameters = Omit<v.InferInput<typeof ReserveRequestWeightActionSchema>, "type">;
 
 /** Request options for the {@linkcode reserveRequestWeight} function. */
 export type ReserveRequestWeightOptions = ExtractRequestOptions<v.InferInput<typeof ReserveRequestWeightRequest>>;
@@ -82,10 +79,9 @@ export type ReserveRequestWeightSuccessResponse = ExcludeErrorResponse<ReserveRe
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * await reserveRequestWeight(
- *   { transport, wallet },
- *   { weight: 10 },
- * );
+ * await reserveRequestWeight({ transport, wallet }, {
+ *   weight: 10,
+ * });
  * ```
  *
  * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#reserve-additional-actions
@@ -95,6 +91,6 @@ export function reserveRequestWeight(
   params: ReserveRequestWeightParameters,
   opts?: ReserveRequestWeightOptions,
 ): Promise<ReserveRequestWeightSuccessResponse> {
-  const action = parse(ReserveRequestWeightParameters, params);
-  return executeL1Action(config, { type: "reserveRequestWeight", ...action }, opts);
+  const action = parse(ReserveRequestWeightActionSchema, { type: "reserveRequestWeight", ...params });
+  return executeL1Action(config, action, opts);
 }

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

@@ -51,16 +51,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 ScheduleCancelParameters = /* @__PURE__ */ (() => {
-  return v.omit(
-    v.object(ScheduleCancelRequest.entries.action.entries),
-    ["type"],
-  );
+/** Schema for action fields (excludes request-level system fields). */
+const ScheduleCancelActionSchema = /* @__PURE__ */ (() => {
+  return v.object(ScheduleCancelRequest.entries.action.entries);
 })();
 
 /** Action parameters for the {@linkcode scheduleCancel} function. */
-export type ScheduleCancelParameters = v.InferInput<typeof ScheduleCancelParameters>;
+export type ScheduleCancelParameters = Omit<v.InferInput<typeof ScheduleCancelActionSchema>, "type">;
 
 /** Request options for the {@linkcode scheduleCancel} function. */
 export type ScheduleCancelOptions = ExtractRequestOptions<v.InferInput<typeof ScheduleCancelRequest>>;
@@ -89,10 +86,9 @@ export type ScheduleCancelSuccessResponse = ExcludeErrorResponse<ScheduleCancelR
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * await scheduleCancel(
- *   { transport, wallet },
- *   { time: Date.now() + 10_000 },
- * );
+ * await scheduleCancel({ transport, wallet }, {
+ *   time: Date.now() + 10_000,
+ * });
  * ```
  *
  * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#schedule-cancel-dead-mans-switch
@@ -115,6 +111,6 @@ export function scheduleCancel(
   const params = isFirstArgParams ? paramsOrOpts : {};
   const opts = isFirstArgParams ? maybeOpts : paramsOrOpts as ScheduleCancelOptions;
 
-  const action = parse(ScheduleCancelParameters, params);
-  return executeL1Action(config, { type: "scheduleCancel", ...action }, opts);
+  const action = parse(ScheduleCancelActionSchema, { type: "scheduleCancel", ...params });
+  return executeL1Action(config, action, opts);
 }

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

@@ -66,16 +66,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 SendAssetParameters = /* @__PURE__ */ (() => {
+/** Schema for action fields (excludes request-level system fields). */
+const SendAssetActionSchema = /* @__PURE__ */ (() => {
   return v.omit(
     v.object(SendAssetRequest.entries.action.entries),
-    ["type", "signatureChainId", "hyperliquidChain", "nonce"],
+    ["signatureChainId", "hyperliquidChain", "nonce"],
   );
 })();
 
 /** Action parameters for the {@linkcode sendAsset} function. */
-export type SendAssetParameters = v.InferInput<typeof SendAssetParameters>;
+export type SendAssetParameters = Omit<v.InferInput<typeof SendAssetActionSchema>, "type">;
 
 /** Request options for the {@linkcode sendAsset} function. */
 export type SendAssetOptions = ExtractRequestOptions<v.InferInput<typeof SendAssetRequest>>;
@@ -118,16 +118,13 @@ export const SendAssetTypes = {
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * await sendAsset(
- *   { transport, wallet },
- *   {
- *     destination: "0x0000000000000000000000000000000000000001",
- *     sourceDex: "",
- *     destinationDex: "test",
- *     token: "USDC:0xeb62eee3685fc4c43992febcd9e75443",
- *     amount: "1",
- *   },
- * );
+ * await sendAsset({ transport, wallet }, {
+ *   destination: "0x0000000000000000000000000000000000000001",
+ *   sourceDex: "",
+ *   destinationDex: "test",
+ *   token: "USDC:0xeb62eee3685fc4c43992febcd9e75443",
+ *   amount: "1",
+ * });
  * ```
  *
  * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#send-asset
@@ -137,11 +134,6 @@ export function sendAsset(
   params: SendAssetParameters,
   opts?: SendAssetOptions,
 ): Promise<SendAssetSuccessResponse> {
-  const action = parse(SendAssetParameters, params);
-  return executeUserSignedAction(
-    config,
-    { type: "sendAsset", ...action },
-    SendAssetTypes,
-    opts,
-  );
+  const action = parse(SendAssetActionSchema, { type: "sendAsset", ...params });
+  return executeUserSignedAction(config, action, SendAssetTypes, opts);
 }

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

@@ -67,16 +67,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 SendToEvmWithDataParameters = /* @__PURE__ */ (() => {
+/** Schema for action fields (excludes request-level system fields). */
+const SendToEvmWithDataActionSchema = /* @__PURE__ */ (() => {
   return v.omit(
     v.object(SendToEvmWithDataRequest.entries.action.entries),
-    ["type", "signatureChainId", "hyperliquidChain", "nonce"],
+    ["signatureChainId", "hyperliquidChain", "nonce"],
   );
 })();
 
 /** Action parameters for the {@linkcode sendToEvmWithData} function. */
-export type SendToEvmWithDataParameters = v.InferInput<typeof SendToEvmWithDataParameters>;
+export type SendToEvmWithDataParameters = Omit<v.InferInput<typeof SendToEvmWithDataActionSchema>, "type">;
 
 /** Request options for the {@linkcode sendToEvmWithData} function. */
 export type SendToEvmWithDataOptions = ExtractRequestOptions<v.InferInput<typeof SendToEvmWithDataRequest>>;
@@ -121,19 +121,16 @@ export const SendToEvmWithDataTypes = {
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * await sendToEvmWithData(
- *   { transport, wallet },
- *   {
- *     token: "USDC",
- *     amount: "1",
- *     sourceDex: "spot",
- *     destinationRecipient: "0x...",
- *     addressEncoding: "hex",
- *     destinationChainId: 42161,
- *     gasLimit: 200000,
- *     data: "0x",
- *   },
- * );
+ * await sendToEvmWithData({ transport, wallet }, {
+ *   token: "USDC",
+ *   amount: "1",
+ *   sourceDex: "spot",
+ *   destinationRecipient: "0x...",
+ *   addressEncoding: "hex",
+ *   destinationChainId: 42161,
+ *   gasLimit: 200000,
+ *   data: "0x",
+ * });
  * ```
  *
  * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#send-to-evm-with-data
@@ -143,11 +140,6 @@ export function sendToEvmWithData(
   params: SendToEvmWithDataParameters,
   opts?: SendToEvmWithDataOptions,
 ): Promise<SendToEvmWithDataSuccessResponse> {
-  const action = parse(SendToEvmWithDataParameters, params);
-  return executeUserSignedAction(
-    config,
-    { type: "sendToEvmWithData", ...action },
-    SendToEvmWithDataTypes,
-    opts,
-  );
+  const action = parse(SendToEvmWithDataActionSchema, { type: "sendToEvmWithData", ...params });
+  return executeUserSignedAction(config, action, SendToEvmWithDataTypes, opts);
 }

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

@@ -47,16 +47,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 SetDisplayNameParameters = /* @__PURE__ */ (() => {
-  return v.omit(
-    v.object(SetDisplayNameRequest.entries.action.entries),
-    ["type"],
-  );
+/** Schema for action fields (excludes request-level system fields). */
+const SetDisplayNameActionSchema = /* @__PURE__ */ (() => {
+  return v.object(SetDisplayNameRequest.entries.action.entries);
 })();
 
 /** Action parameters for the {@linkcode setDisplayName} function. */
-export type SetDisplayNameParameters = v.InferInput<typeof SetDisplayNameParameters>;
+export type SetDisplayNameParameters = Omit<v.InferInput<typeof SetDisplayNameActionSchema>, "type">;
 
 /** Request options for the {@linkcode setDisplayName} function. */
 export type SetDisplayNameOptions = ExtractRequestOptions<v.InferInput<typeof SetDisplayNameRequest>>;
@@ -85,10 +82,9 @@ export type SetDisplayNameSuccessResponse = ExcludeErrorResponse<SetDisplayNameR
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * await setDisplayName(
- *   { transport, wallet },
- *   { displayName: "..." },
- * );
+ * await setDisplayName({ transport, wallet }, {
+ *   displayName: "...",
+ * });
  * ```
  *
  * @see null
@@ -98,6 +94,6 @@ export function setDisplayName(
   params: SetDisplayNameParameters,
   opts?: SetDisplayNameOptions,
 ): Promise<SetDisplayNameSuccessResponse> {
-  const action = parse(SetDisplayNameParameters, params);
-  return executeL1Action(config, { type: "setDisplayName", ...action }, opts);
+  const action = parse(SetDisplayNameActionSchema, { type: "setDisplayName", ...params });
+  return executeL1Action(config, action, opts);
 }

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

@@ -44,16 +44,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 SetReferrerParameters = /* @__PURE__ */ (() => {
-  return v.omit(
-    v.object(SetReferrerRequest.entries.action.entries),
-    ["type"],
-  );
+/** Schema for action fields (excludes request-level system fields). */
+const SetReferrerActionSchema = /* @__PURE__ */ (() => {
+  return v.object(SetReferrerRequest.entries.action.entries);
 })();
 
 /** Action parameters for the {@linkcode setReferrer} function. */
-export type SetReferrerParameters = v.InferInput<typeof SetReferrerParameters>;
+export type SetReferrerParameters = Omit<v.InferInput<typeof SetReferrerActionSchema>, "type">;
 
 /** Request options for the {@linkcode setReferrer} function. */
 export type SetReferrerOptions = ExtractRequestOptions<v.InferInput<typeof SetReferrerRequest>>;
@@ -82,10 +79,9 @@ export type SetReferrerSuccessResponse = ExcludeErrorResponse<SetReferrerRespons
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * await setReferrer(
- *   { transport, wallet },
- *   { code: "..." },
- * );
+ * await setReferrer({ transport, wallet }, {
+ *   code: "...",
+ * });
  * ```
  *
  * @see null
@@ -95,6 +91,6 @@ export function setReferrer(
   params: SetReferrerParameters,
   opts?: SetReferrerOptions,
 ): Promise<SetReferrerSuccessResponse> {
-  const action = parse(SetReferrerParameters, params);
-  return executeL1Action(config, { type: "setReferrer", ...action }, opts);
+  const action = parse(SetReferrerActionSchema, { type: "setReferrer", ...params });
+  return executeL1Action(config, action, opts);
 }

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

@@ -143,15 +143,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 SpotDeployParameters = /* @__PURE__ */ (() => {
-  return v.union(
-    SpotDeployRequest.entries.action.options.map((option) => v.omit(option, ["type"])),
-  );
+/** Schema for action fields (excludes request-level system fields). */
+const SpotDeployActionSchema = /* @__PURE__ */ (() => {
+  return v.variant("type", SpotDeployRequest.entries.action.options);
 })();
 
 /** Action parameters for the {@linkcode spotDeploy} function. */
-export type SpotDeployParameters = v.InferInput<typeof SpotDeployParameters>;
+export type SpotDeployParameters = v.InferInput<typeof SpotDeployActionSchema> extends infer T
+  ? T extends unknown ? { [K in Exclude<keyof T, "type">]: T[K] } : never
+  : never;
 
 /** Request options for the {@linkcode spotDeploy} function. */
 export type SpotDeployOptions = ExtractRequestOptions<v.InferInput<typeof SpotDeployRequest>>;
@@ -180,20 +180,17 @@ export type SpotDeploySuccessResponse = ExcludeErrorResponse<SpotDeployResponse>
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * await spotDeploy(
- *   { transport, wallet },
- *   {
- *     registerToken2: {
- *       spec: {
- *         name: "USDC",
- *         szDecimals: 8,
- *         weiDecimals: 8,
- *       },
- *       maxGas: 1000000,
- *       fullName: "USD Coin",
+ * await spotDeploy({ transport, wallet }, {
+ *   registerToken2: {
+ *     spec: {
+ *       name: "USDC",
+ *       szDecimals: 8,
+ *       weiDecimals: 8,
  *     },
+ *     maxGas: 1000000,
+ *     fullName: "USD Coin",
  *   },
- * );
+ * });
  * ```
  *
  * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/deploying-hip-1-and-hip-2-assets
@@ -203,6 +200,6 @@ export function spotDeploy(
   params: SpotDeployParameters,
   opts?: SpotDeployOptions,
 ): Promise<SpotDeploySuccessResponse> {
-  const action = parse(SpotDeployParameters, params);
-  return executeL1Action(config, { type: "spotDeploy", ...action }, opts);
+  const action = parse(SpotDeployActionSchema, { type: "spotDeploy", ...params });
+  return executeL1Action(config, action, opts);
 }

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

@@ -57,16 +57,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 SpotSendParameters = /* @__PURE__ */ (() => {
+/** Schema for action fields (excludes request-level system fields). */
+const SpotSendActionSchema = /* @__PURE__ */ (() => {
   return v.omit(
     v.object(SpotSendRequest.entries.action.entries),
-    ["type", "signatureChainId", "hyperliquidChain", "time"],
+    ["signatureChainId", "hyperliquidChain", "time"],
   );
 })();
 
 /** Action parameters for the {@linkcode spotSend} function. */
-export type SpotSendParameters = v.InferInput<typeof SpotSendParameters>;
+export type SpotSendParameters = Omit<v.InferInput<typeof SpotSendActionSchema>, "type">;
 
 /** Request options for the {@linkcode spotSend} function. */
 export type SpotSendOptions = ExtractRequestOptions<v.InferInput<typeof SpotSendRequest>>;
@@ -106,14 +106,11 @@ export const SpotSendTypes = {
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * await spotSend(
- *   { transport, wallet },
- *   {
- *     destination: "0x...",
- *     token: "USDC:0xeb62eee3685fc4c43992febcd9e75443",
- *     amount: "1",
- *   },
- * );
+ * await spotSend({ transport, wallet }, {
+ *   destination: "0x...",
+ *   token: "USDC:0xeb62eee3685fc4c43992febcd9e75443",
+ *   amount: "1",
+ * });
  * ```
  *
  * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#core-spot-transfer
@@ -123,11 +120,6 @@ export function spotSend(
   params: SpotSendParameters,
   opts?: SpotSendOptions,
 ): Promise<SpotSendSuccessResponse> {
-  const action = parse(SpotSendParameters, params);
-  return executeUserSignedAction(
-    config,
-    { type: "spotSend", ...action },
-    SpotSendTypes,
-    opts,
-  );
+  const action = parse(SpotSendActionSchema, { type: "spotSend", ...params });
+  return executeUserSignedAction(config, action, SpotSendTypes, opts);
 }

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

@@ -47,16 +47,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 SpotUserParameters = /* @__PURE__ */ (() => {
-  return v.omit(
-    v.object(SpotUserRequest.entries.action.entries),
-    ["type"],
-  );
+/** Schema for action fields (excludes request-level system fields). */
+const SpotUserActionSchema = /* @__PURE__ */ (() => {
+  return v.object(SpotUserRequest.entries.action.entries);
 })();
 
 /** Action parameters for the {@linkcode spotUser} function. */
-export type SpotUserParameters = v.InferInput<typeof SpotUserParameters>;
+export type SpotUserParameters = Omit<v.InferInput<typeof SpotUserActionSchema>, "type">;
 
 /** Request options for the {@linkcode spotUser} function. */
 export type SpotUserOptions = ExtractRequestOptions<v.InferInput<typeof SpotUserRequest>>;
@@ -85,10 +82,9 @@ export type SpotUserSuccessResponse = ExcludeErrorResponse<SpotUserResponse>;
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * await spotUser(
- *   { transport, wallet },
- *   { toggleSpotDusting: { optOut: false } },
- * );
+ * await spotUser({ transport, wallet }, {
+ *   toggleSpotDusting: { optOut: false },
+ * });
  * ```
  *
  * @see null
@@ -98,6 +94,6 @@ export function spotUser(
   params: SpotUserParameters,
   opts?: SpotUserOptions,
 ): Promise<SpotUserSuccessResponse> {
-  const action = parse(SpotUserParameters, params);
-  return executeL1Action(config, { type: "spotUser", ...action }, opts);
+  const action = parse(SpotUserActionSchema, { type: "spotUser", ...params });
+  return executeL1Action(config, action, opts);
 }

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

@@ -46,16 +46,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 SubAccountModifyParameters = /* @__PURE__ */ (() => {
-  return v.omit(
-    v.object(SubAccountModifyRequest.entries.action.entries),
-    ["type"],
-  );
+/** Schema for action fields (excludes request-level system fields). */
+const SubAccountModifyActionSchema = /* @__PURE__ */ (() => {
+  return v.object(SubAccountModifyRequest.entries.action.entries);
 })();
 
 /** Action parameters for the {@linkcode subAccountModify} function. */
-export type SubAccountModifyParameters = v.InferInput<typeof SubAccountModifyParameters>;
+export type SubAccountModifyParameters = Omit<v.InferInput<typeof SubAccountModifyActionSchema>, "type">;
 
 /** Request options for the {@linkcode subAccountModify} function. */
 export type SubAccountModifyOptions = ExtractRequestOptions<v.InferInput<typeof SubAccountModifyRequest>>;
@@ -84,10 +81,10 @@ export type SubAccountModifySuccessResponse = ExcludeErrorResponse<SubAccountMod
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * await subAccountModify(
- *   { transport, wallet },
- *   { subAccountUser: "0x...", name: "..."  },
- * );
+ * await subAccountModify({ transport, wallet }, {
+ *   subAccountUser: "0x...",
+ *   name: "...",
+ * });
  * ```
  *
  * @see null
@@ -97,6 +94,6 @@ export function subAccountModify(
   params: SubAccountModifyParameters,
   opts?: SubAccountModifyOptions,
 ): Promise<SubAccountModifySuccessResponse> {
-  const action = parse(SubAccountModifyParameters, params);
-  return executeL1Action(config, { type: "subAccountModify", ...action }, opts);
+  const action = parse(SubAccountModifyActionSchema, { type: "subAccountModify", ...params });
+  return executeL1Action(config, action, opts);
 }