@nktkas/hyperliquid 0.32.0 → 0.32.2

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

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