@nktkas/hyperliquid 0.32.1 → 0.32.2

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

@@ -57,16 +57,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 CreateSubAccountParameters = /* @__PURE__ */ (() => {
-  return v.omit(
-    v.object(CreateSubAccountRequest.entries.action.entries),
-    ["type"],
-  );
+/** Schema for action fields (excludes request-level system fields). */
+const CreateSubAccountActionSchema = /* @__PURE__ */ (() => {
+  return v.object(CreateSubAccountRequest.entries.action.entries);
 })();
 
 /** Action parameters for the {@linkcode createSubAccount} function. */
-export type CreateSubAccountParameters = v.InferInput<typeof CreateSubAccountParameters>;
+export type CreateSubAccountParameters = Omit<v.InferInput<typeof CreateSubAccountActionSchema>, "type">;
 
 /** Request options for the {@linkcode createSubAccount} function. */
 export type CreateSubAccountOptions = ExtractRequestOptions<v.InferInput<typeof CreateSubAccountRequest>>;
@@ -95,10 +92,9 @@ export type CreateSubAccountSuccessResponse = ExcludeErrorResponse<CreateSubAcco
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * const data = await createSubAccount(
- *   { transport, wallet },
- *   { name: "..." },
- * );
+ * const data = await createSubAccount({ transport, wallet }, {
+ *   name: "...",
+ * });
  * ```
  *
  * @see null
@@ -108,6 +104,6 @@ export function createSubAccount(
   params: CreateSubAccountParameters,
   opts?: CreateSubAccountOptions,
 ): Promise<CreateSubAccountSuccessResponse> {
-  const action = parse(CreateSubAccountParameters, params);
-  return executeL1Action(config, { type: "createSubAccount", ...action }, opts);
+  const action = parse(CreateSubAccountActionSchema, { type: "createSubAccount", ...params });
+  return executeL1Action(config, action, opts);
 }

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

@@ -63,16 +63,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 CreateVaultParameters = /* @__PURE__ */ (() => {
-  return v.omit(
-    v.object(CreateVaultRequest.entries.action.entries),
-    ["type"],
-  );
+/** Schema for action fields (excludes request-level system fields). */
+const CreateVaultActionSchema = /* @__PURE__ */ (() => {
+  return v.object(CreateVaultRequest.entries.action.entries);
 })();
 
 /** Action parameters for the {@linkcode createVault} function. */
-export type CreateVaultParameters = v.InferInput<typeof CreateVaultParameters>;
+export type CreateVaultParameters = Omit<v.InferInput<typeof CreateVaultActionSchema>, "type">;
 
 /** Request options for the {@linkcode createVault} function. */
 export type CreateVaultOptions = ExtractRequestOptions<v.InferInput<typeof CreateVaultRequest>>;
@@ -101,15 +98,12 @@ export type CreateVaultSuccessResponse = ExcludeErrorResponse<CreateVaultRespons
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * const data = await createVault(
- *   { transport, wallet },
- *   {
- *     name: "...",
- *     description: "...",
- *     initialUsd: 100 * 1e6,
- *     nonce: Date.now(),
- *   },
- * );
+ * const data = await createVault({ transport, wallet }, {
+ *   name: "...",
+ *   description: "...",
+ *   initialUsd: 100 * 1e6,
+ *   nonce: Date.now(),
+ * });
  * ```
  *
  * @see null
@@ -119,6 +113,6 @@ export function createVault(
   params: CreateVaultParameters,
   opts?: CreateVaultOptions,
 ): Promise<CreateVaultSuccessResponse> {
-  const action = parse(CreateVaultParameters, params);
-  return executeL1Action(config, { type: "createVault", ...action }, opts);
+  const action = parse(CreateVaultActionSchema, { type: "createVault", ...params });
+  return executeL1Action(config, action, opts);
 }

package/src/api/exchange/_methods/evmUserModify.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 EvmUserModifyParameters = /* @__PURE__ */ (() => {
-  return v.omit(
-    v.object(EvmUserModifyRequest.entries.action.entries),
-    ["type"],
-  );
+/** Schema for action fields (excludes request-level system fields). */
+const EvmUserModifyActionSchema = /* @__PURE__ */ (() => {
+  return v.object(EvmUserModifyRequest.entries.action.entries);
 })();
 
 /** Action parameters for the {@linkcode evmUserModify} function. */
-export type EvmUserModifyParameters = v.InferInput<typeof EvmUserModifyParameters>;
+export type EvmUserModifyParameters = Omit<v.InferInput<typeof EvmUserModifyActionSchema>, "type">;
 
 /** Request options for the {@linkcode evmUserModify} function. */
 export type EvmUserModifyOptions = ExtractRequestOptions<v.InferInput<typeof EvmUserModifyRequest>>;
@@ -82,10 +79,9 @@ export type EvmUserModifySuccessResponse = ExcludeErrorResponse<EvmUserModifyRes
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * await evmUserModify(
- *   { transport, wallet },
- *   { usingBigBlocks: true },
- * );
+ * await evmUserModify({ transport, wallet }, {
+ *   usingBigBlocks: true,
+ * });
  * ```
  *
  * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/hyperevm/dual-block-architecture
@@ -95,6 +91,6 @@ export function evmUserModify(
   params: EvmUserModifyParameters,
   opts?: EvmUserModifyOptions,
 ): Promise<EvmUserModifySuccessResponse> {
-  const action = parse(EvmUserModifyParameters, params);
-  return executeL1Action(config, { type: "evmUserModify", ...action }, opts);
+  const action = parse(EvmUserModifyActionSchema, { type: "evmUserModify", ...params });
+  return executeL1Action(config, action, opts);
 }

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

@@ -63,16 +63,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 LinkStakingUserParameters = /* @__PURE__ */ (() => {
+/** Schema for action fields (excludes request-level system fields). */
+const LinkStakingUserActionSchema = /* @__PURE__ */ (() => {
   return v.omit(
     v.object(LinkStakingUserRequest.entries.action.entries),
-    ["type", "signatureChainId", "hyperliquidChain", "nonce"],
+    ["signatureChainId", "hyperliquidChain", "nonce"],
   );
 })();
 
 /** Action parameters for the {@linkcode linkStakingUser} function. */
-export type LinkStakingUserParameters = v.InferInput<typeof LinkStakingUserParameters>;
+export type LinkStakingUserParameters = Omit<v.InferInput<typeof LinkStakingUserActionSchema>, "type">;
 
 /** Request options for the {@linkcode linkStakingUser} function. */
 export type LinkStakingUserOptions = ExtractRequestOptions<v.InferInput<typeof LinkStakingUserRequest>>;
@@ -111,10 +111,10 @@ export const LinkStakingUserTypes = {
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * await linkStakingUser(
- *   { transport, wallet },
- *   { user: "0x...", isFinalize: false },
- * );
+ * await linkStakingUser({ transport, wallet }, {
+ *   user: "0x...",
+ *   isFinalize: false,
+ * });
  * ```
  *
  * @see https://hyperliquid.gitbook.io/hyperliquid-docs/trading/fees#staking-linking
@@ -124,11 +124,6 @@ export function linkStakingUser(
   params: LinkStakingUserParameters,
   opts?: LinkStakingUserOptions,
 ): Promise<LinkStakingUserSuccessResponse> {
-  const action = parse(LinkStakingUserParameters, params);
-  return executeUserSignedAction(
-    config,
-    { type: "linkStakingUser", ...action },
-    LinkStakingUserTypes,
-    opts,
-  );
+  const action = parse(LinkStakingUserActionSchema, { type: "linkStakingUser", ...params });
+  return executeUserSignedAction(config, action, LinkStakingUserTypes, opts);
 }

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

@@ -94,16 +94,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 ModifyParameters = /* @__PURE__ */ (() => {
-  return v.omit(
-    v.object(ModifyRequest.entries.action.entries),
-    ["type"],
-  );
+/** Schema for action fields (excludes request-level system fields). */
+const ModifyActionSchema = /* @__PURE__ */ (() => {
+  return v.object(ModifyRequest.entries.action.entries);
 })();
 
 /** Action parameters for the {@linkcode modify} function. */
-export type ModifyParameters = v.InferInput<typeof ModifyParameters>;
+export type ModifyParameters = Omit<v.InferInput<typeof ModifyActionSchema>, "type">;
 
 /** Request options for the {@linkcode modify} function. */
 export type ModifyOptions = ExtractRequestOptions<v.InferInput<typeof ModifyRequest>>;
@@ -132,20 +129,17 @@ export type ModifySuccessResponse = ExcludeErrorResponse<ModifyResponse>;
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * await modify(
- *   { transport, wallet },
- *   {
- *     oid: 123,
- *     order: {
- *       a: 0,
- *       b: true,
- *       p: "31000",
- *       s: "0.2",
- *       r: false,
- *       t: { limit: { tif: "Gtc" } },
- *     },
+ * await modify({ transport, wallet }, {
+ *   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-an-order
@@ -155,6 +149,6 @@ export function modify(
   params: ModifyParameters,
   opts?: ModifyOptions,
 ): Promise<ModifySuccessResponse> {
-  const action = parse(ModifyParameters, params);
-  return executeL1Action(config, { type: "modify", ...action }, opts);
+  const action = parse(ModifyActionSchema, { type: "modify", ...params });
+  return executeL1Action(config, action, opts);
 }

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

@@ -38,9 +38,15 @@ export type NoopResponse = 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 NoopActionSchema = /* @__PURE__ */ (() => {
+  return v.object(NoopRequest.entries.action.entries);
+})();
+
 /** Request options for the {@linkcode noop} function. */
 export type NoopOptions = ExtractRequestOptions<v.InferInput<typeof NoopRequest>>;
 
@@ -76,5 +82,6 @@ export function noop(
   config: ExchangeConfig,
   opts?: NoopOptions,
 ): Promise<NoopSuccessResponse> {
-  return executeL1Action(config, { type: "noop" }, opts);
+  const action = parse(NoopActionSchema, { type: "noop" });
+  return executeL1Action(config, action, opts);
 }

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

@@ -123,7 +123,7 @@ export type OrderResponse = {
              * Client Order ID.
              * @pattern ^0x[a-fA-F0-9]{32}$
              */
-            cloid?: `0x${string}` | undefined;
+            cloid?: `0x${string}`;
           };
         }
         | {
@@ -145,7 +145,7 @@ export type OrderResponse = {
              * Client Order ID.
              * @pattern ^0x[a-fA-F0-9]{32}$
              */
-            cloid?: `0x${string}` | undefined;
+            cloid?: `0x${string}`;
           };
         }
         | {
@@ -167,16 +167,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 OrderParameters = /* @__PURE__ */ (() => {
-  return v.omit(
-    v.object(OrderRequest.entries.action.entries),
-    ["type"],
-  );
+/** Schema for action fields (excludes request-level system fields). */
+const OrderActionSchema = /* @__PURE__ */ (() => {
+  return v.object(OrderRequest.entries.action.entries);
 })();
 
 /** Action parameters for the {@linkcode order} function. */
-export type OrderParameters = v.InferInput<typeof OrderParameters>;
+export type OrderParameters = Omit<v.InferInput<typeof OrderActionSchema>, "type">;
 
 /** Request options for the {@linkcode order} function. */
 export type OrderOptions = ExtractRequestOptions<v.InferInput<typeof OrderRequest>>;
@@ -205,22 +202,19 @@ export type OrderSuccessResponse = ExcludeErrorResponse<OrderResponse>;
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  *
- * const data = await order(
- *   { transport, wallet },
- *   {
- *     orders: [
- *       {
- *         a: 0,
- *         b: true,
- *         p: "30000",
- *         s: "0.1",
- *         r: false,
- *         t: { limit: { tif: "Gtc" } },
- *       },
- *     ],
- *     grouping: "na",
- *   },
- * );
+ * const data = await order({ transport, wallet }, {
+ *   orders: [
+ *     {
+ *       a: 0,
+ *       b: true,
+ *       p: "30000",
+ *       s: "0.1",
+ *       r: false,
+ *       t: { limit: { tif: "Gtc" } },
+ *     },
+ *   ],
+ *   grouping: "na",
+ * });
  * ```
  *
  * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#place-an-order
@@ -230,6 +224,6 @@ export function order(
   params: OrderParameters,
   opts?: OrderOptions,
 ): Promise<OrderSuccessResponse> {
-  const action = parse(OrderParameters, params);
-  return executeL1Action(config, { type: "order", ...action }, opts);
+  const action = parse(OrderActionSchema, { type: "order", ...params });
+  return executeL1Action(config, action, opts);
 }

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

@@ -200,6 +200,10 @@ export const PerpDeployRequest = /* @__PURE__ */ (() => {
           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()),
         }),
       }),
     ]),
@@ -227,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>>;
@@ -264,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
@@ -290,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);
 }