@nktkas/hyperliquid 0.25.7 → 0.25.9

package/src/src/api/exchange/tokenDelegate.ts

@@ -6,7 +6,6 @@ import {
   type ExtractRequestAction,
   type ExtractRequestOptions,
   getSignatureChainId,
-  globalNonceManager,
   type MultiSignRequestConfig,
   Signature,
 } from "./_base/mod.js";
@@ -129,16 +128,20 @@ export async function tokenDelegate(
   params: DeepImmutable<TokenDelegateParameters>,
   opts?: TokenDelegateOptions,
 ): Promise<SuccessResponse> {
-  const action = parser(TokenDelegateRequest.entries.action)({
-    type: "tokenDelegate",
-    hyperliquidChain: config.transport.isTestnet ? "Testnet" : "Mainnet",
-    signatureChainId: await getSignatureChainId(config),
-    nonce: globalNonceManager.getNonce(),
-    ...params,
+  const request = parser(TokenDelegateRequest)({
+    action: {
+      type: "tokenDelegate",
+      hyperliquidChain: config.transport.isTestnet ? "Testnet" : "Mainnet",
+      signatureChainId: await getSignatureChainId(config),
+      nonce: 0, // Placeholder; actual nonce generated in `executeUserSignedAction` to prevent race conditions
+      ...params,
+    },
+    nonce: 0, // Placeholder; actual nonce generated in `executeUserSignedAction` to prevent race conditions
+    signature: { // Placeholder; actual signature generated in `executeUserSignedAction`
+      r: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      s: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      v: 27,
+    },
   });
-  return await executeUserSignedAction(
-    config,
-    { action, types: TokenDelegateTypes },
-    opts?.signal,
-  );
+  return await executeUserSignedAction(config, request, TokenDelegateTypes, opts?.signal);
 }

package/src/src/api/exchange/twapCancel.ts

@@ -186,18 +186,21 @@ export async function twapCancel(
   params: DeepImmutable<TwapCancelParameters>,
   opts?: TwapCancelOptions,
 ): Promise<TwapCancelSuccessResponse> {
-  const action = parser(TwapCancelRequest.entries.action)({
-    type: "twapCancel",
-    ...params,
+  const request = parser(TwapCancelRequest)({
+    action: {
+      type: "twapCancel",
+      ...params,
+    },
+    nonce: 0, // Placeholder; actual nonce generated in `executeL1Action`
+    signature: { // Placeholder; actual signature generated in `executeL1Action`
+      r: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      s: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      v: 27,
+    },
+    vaultAddress: opts?.vaultAddress ?? config.defaultVaultAddress,
+    expiresAfter: typeof config.defaultExpiresAfter === "number"
+      ? config.defaultExpiresAfter
+      : await config.defaultExpiresAfter?.(),
   });
-
-  const vaultAddress_ = opts?.vaultAddress ?? config.defaultVaultAddress;
-  const vaultAddress = parser(v.optional(Address))(vaultAddress_);
-
-  const expiresAfter_ = typeof config.defaultExpiresAfter === "number"
-    ? config.defaultExpiresAfter
-    : await config.defaultExpiresAfter?.();
-  const expiresAfter = parser(v.optional(UnsignedInteger))(expiresAfter_);
-
-  return await executeL1Action(config, { action, vaultAddress, expiresAfter }, opts?.signal);
+  return await executeL1Action(config, request, opts?.signal);
 }

package/src/src/api/exchange/twapOrder.ts

@@ -245,18 +245,21 @@ export async function twapOrder(
   params: DeepImmutable<TwapOrderParameters>,
   opts?: TwapOrderOptions,
 ): Promise<TwapOrderSuccessResponse> {
-  const action = parser(TwapOrderRequest.entries.action)({
-    type: "twapOrder",
-    ...params,
+  const request = parser(TwapOrderRequest)({
+    action: {
+      type: "twapOrder",
+      ...params,
+    },
+    nonce: 0, // Placeholder; actual nonce generated in `executeL1Action`
+    signature: { // Placeholder; actual signature generated in `executeL1Action`
+      r: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      s: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      v: 27,
+    },
+    vaultAddress: opts?.vaultAddress ?? config.defaultVaultAddress,
+    expiresAfter: typeof config.defaultExpiresAfter === "number"
+      ? config.defaultExpiresAfter
+      : await config.defaultExpiresAfter?.(),
   });
-
-  const vaultAddress_ = opts?.vaultAddress ?? config.defaultVaultAddress;
-  const vaultAddress = parser(v.optional(Address))(vaultAddress_);
-
-  const expiresAfter_ = typeof config.defaultExpiresAfter === "number"
-    ? config.defaultExpiresAfter
-    : await config.defaultExpiresAfter?.();
-  const expiresAfter = parser(v.optional(UnsignedInteger))(expiresAfter_);
-
-  return await executeL1Action(config, { action, vaultAddress, expiresAfter }, opts?.signal);
+  return await executeL1Action(config, request, opts?.signal);
 }

package/src/src/api/exchange/updateIsolatedMargin.ts

@@ -111,18 +111,21 @@ export async function updateIsolatedMargin(
   params: DeepImmutable<UpdateIsolatedMarginParameters>,
   opts?: UpdateIsolatedMarginOptions,
 ): Promise<SuccessResponse> {
-  const action = parser(UpdateIsolatedMarginRequest.entries.action)({
-    type: "updateIsolatedMargin",
-    ...params,
+  const request = parser(UpdateIsolatedMarginRequest)({
+    action: {
+      type: "updateIsolatedMargin",
+      ...params,
+    },
+    nonce: 0, // Placeholder; actual nonce generated in `executeL1Action`
+    signature: { // Placeholder; actual signature generated in `executeL1Action`
+      r: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      s: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      v: 27,
+    },
+    vaultAddress: opts?.vaultAddress ?? config.defaultVaultAddress,
+    expiresAfter: typeof config.defaultExpiresAfter === "number"
+      ? config.defaultExpiresAfter
+      : await config.defaultExpiresAfter?.(),
   });
-
-  const vaultAddress_ = opts?.vaultAddress ?? config.defaultVaultAddress;
-  const vaultAddress = parser(v.optional(Address))(vaultAddress_);
-
-  const expiresAfter_ = typeof config.defaultExpiresAfter === "number"
-    ? config.defaultExpiresAfter
-    : await config.defaultExpiresAfter?.();
-  const expiresAfter = parser(v.optional(UnsignedInteger))(expiresAfter_);
-
-  return await executeL1Action(config, { action, vaultAddress, expiresAfter }, opts?.signal);
+  return await executeL1Action(config, request, opts?.signal);
 }

package/src/src/api/exchange/updateLeverage.ts

@@ -111,18 +111,21 @@ export async function updateLeverage(
   params: DeepImmutable<UpdateLeverageParameters>,
   opts?: UpdateLeverageOptions,
 ): Promise<SuccessResponse> {
-  const action = parser(UpdateLeverageRequest.entries.action)({
-    type: "updateLeverage",
-    ...params,
+  const request = parser(UpdateLeverageRequest)({
+    action: {
+      type: "updateLeverage",
+      ...params,
+    },
+    nonce: 0, // Placeholder; actual nonce generated in `executeL1Action`
+    signature: { // Placeholder; actual signature generated in `executeL1Action`
+      r: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      s: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      v: 27,
+    },
+    vaultAddress: opts?.vaultAddress ?? config.defaultVaultAddress,
+    expiresAfter: typeof config.defaultExpiresAfter === "number"
+      ? config.defaultExpiresAfter
+      : await config.defaultExpiresAfter?.(),
   });
-
-  const vaultAddress_ = opts?.vaultAddress ?? config.defaultVaultAddress;
-  const vaultAddress = parser(v.optional(Address))(vaultAddress_);
-
-  const expiresAfter_ = typeof config.defaultExpiresAfter === "number"
-    ? config.defaultExpiresAfter
-    : await config.defaultExpiresAfter?.();
-  const expiresAfter = parser(v.optional(UnsignedInteger))(expiresAfter_);
-
-  return await executeL1Action(config, { action, vaultAddress, expiresAfter }, opts?.signal);
+  return await executeL1Action(config, request, opts?.signal);
 }

package/src/src/api/exchange/usdClassTransfer.ts

@@ -6,7 +6,6 @@ import {
   type ExtractRequestAction,
   type ExtractRequestOptions,
   getSignatureChainId,
-  globalNonceManager,
   type MultiSignRequestConfig,
   Signature,
 } from "./_base/mod.js";
@@ -123,16 +122,20 @@ export async function usdClassTransfer(
   params: DeepImmutable<UsdClassTransferParameters>,
   opts?: UsdClassTransferOptions,
 ): Promise<SuccessResponse> {
-  const action = parser(UsdClassTransferRequest.entries.action)({
-    type: "usdClassTransfer",
-    hyperliquidChain: config.transport.isTestnet ? "Testnet" : "Mainnet",
-    signatureChainId: await getSignatureChainId(config),
-    nonce: globalNonceManager.getNonce(),
-    ...params,
+  const request = parser(UsdClassTransferRequest)({
+    action: {
+      type: "usdClassTransfer",
+      hyperliquidChain: config.transport.isTestnet ? "Testnet" : "Mainnet",
+      signatureChainId: await getSignatureChainId(config),
+      nonce: 0, // Placeholder; actual nonce generated in `executeUserSignedAction` to prevent race conditions
+      ...params,
+    },
+    nonce: 0, // Placeholder; actual nonce generated in `executeUserSignedAction` to prevent race conditions
+    signature: { // Placeholder; actual signature generated in `executeUserSignedAction`
+      r: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      s: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      v: 27,
+    },
   });
-  return await executeUserSignedAction(
-    config,
-    { action, types: UsdClassTransferTypes },
-    opts?.signal,
-  );
+  return await executeUserSignedAction(config, request, UsdClassTransferTypes, opts?.signal);
 }

package/src/src/api/exchange/usdSend.ts

@@ -6,7 +6,6 @@ import {
   type ExtractRequestAction,
   type ExtractRequestOptions,
   getSignatureChainId,
-  globalNonceManager,
   type MultiSignRequestConfig,
   Signature,
 } from "./_base/mod.js";
@@ -123,16 +122,20 @@ export async function usdSend(
   params: DeepImmutable<UsdSendParameters>,
   opts?: UsdSendOptions,
 ): Promise<SuccessResponse> {
-  const action = parser(UsdSendRequest.entries.action)({
-    type: "usdSend",
-    hyperliquidChain: config.transport.isTestnet ? "Testnet" : "Mainnet",
-    signatureChainId: await getSignatureChainId(config),
-    time: globalNonceManager.getNonce(),
-    ...params,
+  const request = parser(UsdSendRequest)({
+    action: {
+      type: "usdSend",
+      hyperliquidChain: config.transport.isTestnet ? "Testnet" : "Mainnet",
+      signatureChainId: await getSignatureChainId(config),
+      time: 0, // Placeholder; actual nonce generated in `executeUserSignedAction` to prevent race conditions
+      ...params,
+    },
+    nonce: 0, // Placeholder; actual nonce generated in `executeUserSignedAction` to prevent race conditions
+    signature: { // Placeholder; actual signature generated in `executeUserSignedAction`
+      r: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      s: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      v: 27,
+    },
   });
-  return await executeUserSignedAction(
-    config,
-    { action, types: UsdSendTypes },
-    opts?.signal,
-  );
+  return await executeUserSignedAction(config, request, UsdSendTypes, opts?.signal);
 }

package/src/src/api/exchange/userDexAbstraction.ts

@@ -6,7 +6,6 @@ import {
   type ExtractRequestAction,
   type ExtractRequestOptions,
   getSignatureChainId,
-  globalNonceManager,
   type MultiSignRequestConfig,
   Signature,
 } from "./_base/mod.js";
@@ -127,16 +126,20 @@ export async function userDexAbstraction(
   params: DeepImmutable<UserDexAbstractionExchangeParameters>,
   opts?: UserDexAbstractionExchangeOptions,
 ): Promise<SuccessResponse> {
-  const action = parser(UserDexAbstractionExchangeRequest.entries.action)({
-    type: "userDexAbstraction",
-    hyperliquidChain: config.transport.isTestnet ? "Testnet" : "Mainnet",
-    signatureChainId: await getSignatureChainId(config),
-    nonce: globalNonceManager.getNonce(),
-    ...params,
+  const request = parser(UserDexAbstractionExchangeRequest)({
+    action: {
+      type: "userDexAbstraction",
+      hyperliquidChain: config.transport.isTestnet ? "Testnet" : "Mainnet",
+      signatureChainId: await getSignatureChainId(config),
+      nonce: 0, // Placeholder; actual nonce generated in `executeUserSignedAction` to prevent race conditions
+      ...params,
+    },
+    nonce: 0, // Placeholder; actual nonce generated in `executeUserSignedAction` to prevent race conditions
+    signature: { // Placeholder; actual signature generated in `executeUserSignedAction`
+      r: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      s: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      v: 27,
+    },
   });
-  return await executeUserSignedAction(
-    config,
-    { action, types: UserDexAbstractionTypes },
-    opts?.signal,
-  );
+  return await executeUserSignedAction(config, request, UserDexAbstractionTypes, opts?.signal);
 }

package/src/src/api/exchange/vaultDistribute.ts

@@ -108,15 +108,20 @@ export async function vaultDistribute(
   params: DeepImmutable<VaultDistributeParameters>,
   opts?: VaultDistributeOptions,
 ): Promise<SuccessResponse> {
-  const action = parser(VaultDistributeRequest.entries.action)({
-    type: "vaultDistribute",
-    ...params,
+  const request = parser(VaultDistributeRequest)({
+    action: {
+      type: "vaultDistribute",
+      ...params,
+    },
+    nonce: 0, // Placeholder; actual nonce generated in `executeL1Action`
+    signature: { // Placeholder; actual signature generated in `executeL1Action`
+      r: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      s: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      v: 27,
+    },
+    expiresAfter: typeof config.defaultExpiresAfter === "number"
+      ? config.defaultExpiresAfter
+      : await config.defaultExpiresAfter?.(),
   });
-
-  const expiresAfter_ = typeof config.defaultExpiresAfter === "number"
-    ? config.defaultExpiresAfter
-    : await config.defaultExpiresAfter?.();
-  const expiresAfter = parser(v.optional(UnsignedInteger))(expiresAfter_);
-
-  return await executeL1Action(config, { action, expiresAfter }, opts?.signal);
+  return await executeL1Action(config, request, opts?.signal);
 }

package/src/src/api/exchange/vaultModify.ts

@@ -110,15 +110,20 @@ export async function vaultModify(
   params: DeepImmutable<VaultModifyParameters>,
   opts?: VaultModifyOptions,
 ): Promise<SuccessResponse> {
-  const action = parser(VaultModifyRequest.entries.action)({
-    type: "vaultModify",
-    ...params,
+  const request = parser(VaultModifyRequest)({
+    action: {
+      type: "vaultModify",
+      ...params,
+    },
+    nonce: 0, // Placeholder; actual nonce generated in `executeL1Action`
+    signature: { // Placeholder; actual signature generated in `executeL1Action`
+      r: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      s: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      v: 27,
+    },
+    expiresAfter: typeof config.defaultExpiresAfter === "number"
+      ? config.defaultExpiresAfter
+      : await config.defaultExpiresAfter?.(),
   });
-
-  const expiresAfter_ = typeof config.defaultExpiresAfter === "number"
-    ? config.defaultExpiresAfter
-    : await config.defaultExpiresAfter?.();
-  const expiresAfter = parser(v.optional(UnsignedInteger))(expiresAfter_);
-
-  return await executeL1Action(config, { action, expiresAfter }, opts?.signal);
+  return await executeL1Action(config, request, opts?.signal);
 }

package/src/src/api/exchange/vaultTransfer.ts

@@ -106,15 +106,20 @@ export async function vaultTransfer(
   params: DeepImmutable<VaultTransferParameters>,
   opts?: VaultTransferOptions,
 ): Promise<SuccessResponse> {
-  const action = parser(VaultTransferRequest.entries.action)({
-    type: "vaultTransfer",
-    ...params,
+  const request = parser(VaultTransferRequest)({
+    action: {
+      type: "vaultTransfer",
+      ...params,
+    },
+    nonce: 0, // Placeholder; actual nonce generated in `executeL1Action`
+    signature: { // Placeholder; actual signature generated in `executeL1Action`
+      r: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      s: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      v: 27,
+    },
+    expiresAfter: typeof config.defaultExpiresAfter === "number"
+      ? config.defaultExpiresAfter
+      : await config.defaultExpiresAfter?.(),
   });
-
-  const expiresAfter_ = typeof config.defaultExpiresAfter === "number"
-    ? config.defaultExpiresAfter
-    : await config.defaultExpiresAfter?.();
-  const expiresAfter = parser(v.optional(UnsignedInteger))(expiresAfter_);
-
-  return await executeL1Action(config, { action, expiresAfter }, opts?.signal);
+  return await executeL1Action(config, request, opts?.signal);
 }

package/src/src/api/exchange/withdraw3.ts

@@ -6,7 +6,6 @@ import {
   type ExtractRequestAction,
   type ExtractRequestOptions,
   getSignatureChainId,
-  globalNonceManager,
   type MultiSignRequestConfig,
   Signature,
 } from "./_base/mod.js";
@@ -123,16 +122,20 @@ export async function withdraw3(
   params: DeepImmutable<Withdraw3Parameters>,
   opts?: Withdraw3Options,
 ): Promise<SuccessResponse> {
-  const action = parser(Withdraw3Request.entries.action)({
-    type: "withdraw3",
-    hyperliquidChain: config.transport.isTestnet ? "Testnet" : "Mainnet",
-    signatureChainId: await getSignatureChainId(config),
-    time: globalNonceManager.getNonce(),
-    ...params,
+  const request = parser(Withdraw3Request)({
+    action: {
+      type: "withdraw3",
+      hyperliquidChain: config.transport.isTestnet ? "Testnet" : "Mainnet",
+      signatureChainId: await getSignatureChainId(config),
+      time: 0, // Placeholder; actual nonce generated in `executeUserSignedAction` to prevent race conditions
+      ...params,
+    },
+    nonce: 0, // Placeholder; actual nonce generated in `executeUserSignedAction` to prevent race conditions
+    signature: { // Placeholder; actual signature generated in `executeUserSignedAction`
+      r: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      s: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      v: 27,
+    },
   });
-  return await executeUserSignedAction(
-    config,
-    { action, types: Withdraw3Types },
-    opts?.signal,
-  );
+  return await executeUserSignedAction(config, request, Withdraw3Types, opts?.signal);
 }

package/src/src/api/exchange/~client.ts

@@ -2,7 +2,7 @@ import type { MaybePromise, OmitFirst, OverloadedParameters } from "../_base.js"
 import type { ExchangeRequestConfig, MultiSignRequestConfig } from "./_base/mod.js";
 import type { IRequestTransport } from "../../transport/base.js";
 import type { AbstractWallet } from "../../signing/mod.js";
-import { PrivateKeyEIP712Signer } from "../../utils/_minimalEIP712Signer.js";
+import { PrivateKeyEIP712Signer } from "../../utils/_eip712.js";
 
 import { agentEnableDexAbstraction } from "./agentEnableDexAbstraction.js";
 import { approveAgent } from "./approveAgent.js";
@@ -19,6 +19,7 @@ import { cSignerAction } from "./cSignerAction.js";
 import { cValidatorAction } from "./cValidatorAction.js";
 import { cWithdraw } from "./cWithdraw.js";
 import { evmUserModify } from "./evmUserModify.js";
+import { linkStakingUser } from "./linkStakingUser.js";
 import { modify } from "./modify.js";
 import { multiSig } from "./multiSig.js";
 import { order } from "./order.js";
@@ -64,6 +65,7 @@ export type { CSignerActionOptions, CSignerActionParameters } from "./cSignerAct
 export type { CValidatorActionOptions, CValidatorActionParameters } from "./cValidatorAction.js";
 export type { CWithdrawOptions, CWithdrawParameters } from "./cWithdraw.js";
 export type { EvmUserModifyOptions, EvmUserModifyParameters } from "./evmUserModify.js";
+export type { LinkStakingUserOptions, LinkStakingUserParameters } from "./linkStakingUser.js";
 export type { ModifyOptions, ModifyParameters } from "./modify.js";
 export type { MultiSigOptions, MultiSigParameters } from "./multiSig.js";
 export type { OrderOptions, OrderParameters } from "./order.js";
@@ -118,7 +120,6 @@ export class ExchangeClient<
   signatureChainId?: string | (() => MaybePromise<string>);
   defaultVaultAddress?: string;
   defaultExpiresAfter?: number | (() => MaybePromise<number>);
-  sequentialRequests?: boolean;
 
   /**
    * Initialises a new instance.
@@ -181,7 +182,6 @@ export class ExchangeClient<
     this.defaultVaultAddress = args.defaultVaultAddress;
     this.defaultExpiresAfter = args.defaultExpiresAfter;
     this.signatureChainId = args.signatureChainId;
-    this.sequentialRequests = args.sequentialRequests;
   }
 
   /**
@@ -609,7 +609,7 @@ export class ExchangeClient<
    * Configure block type for EVM transactions.
    * @param params - Parameters specific to the API request.
    * @param opts - Request execution options.
-   * @returns Response for creating a sub-account.
+   * @returns Successful response without specific data.
    *
    * @throws {ApiRequestError} When the API returns an unsuccessful response.
    * @throws {TransportError} When the transport layer throws an error.
@@ -630,6 +630,31 @@ export class ExchangeClient<
     return evmUserModify(this, ...args);
   }
 
+  /**
+   * Link staking and trading accounts for fee discount attribution.
+   * @param params - Parameters specific to the API request.
+   * @param opts - Request execution options.
+   * @returns Successful response without specific data.
+   *
+   * @throws {ApiRequestError} When the API returns an unsuccessful response.
+   * @throws {TransportError} When the transport layer throws an error.
+   *
+   * @see https://hyperliquid.gitbook.io/hyperliquid-docs/trading/fees#staking-linking
+   * @example
+   * ```ts
+   * import * as hl from "@nktkas/hyperliquid";
+   *
+   * const pk = "0x..."; // viem, ethers or private key
+   * const transport = new hl.HttpTransport(); // or `WebSocketTransport`
+   *
+   * const client = new hl.ExchangeClient({ transport, wallet: pk });
+   * await client.linkStakingUser({ user: "0x...", isFinalize: false });
+   * ```
+   */
+  linkStakingUser(...args: OmitFirst<OverloadedParameters<typeof linkStakingUser>>) {
+    return linkStakingUser(this, ...args);
+  }
+
   /**
    * Modify an order.
    * @param params - Parameters specific to the API request.
@@ -1492,7 +1517,7 @@ export class MultiSignClient<
   /**
    * @note Is the first wallet from {@linkcode signers}. Changing the property also changes the first element in the {@linkcode signers} array.
    */
-  declare readonly wallet: S[0];
+  declare wallet: S[0];
 
   /**
    * Initialises a new multi-signature client instance.

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

@@ -55,6 +55,7 @@ export * from "./cSignerAction.js";
 export * from "./cValidatorAction.js";
 export * from "./cWithdraw.js";
 export * from "./evmUserModify.js";
+export * from "./linkStakingUser.js";
 export * from "./modify.js";
 export * from "./multiSig.js";
 export * from "./order.js";

package/src/src/api/info/meta.ts

@@ -73,6 +73,13 @@ export const MetaResponse = /* @__PURE__ */ (() => {
                 v.optional(v.literal(true)),
                 v.description("Indicates if the universe is delisted."),
               ),
+              /** Trading margin mode constraint. */
+              marginMode: v.pipe(
+                v.optional(
+                  v.union([v.literal("strictIsolated"), v.literal("noCross")]),
+                ),
+                v.description("Trading margin mode constraint."),
+              ),
             }),
             v.description("Trading universe parameters for perpetual asset."),
           ),

package/src/src/api/info/perpDexs.ts

@@ -63,6 +63,16 @@ export const PerpDexsResponse = /* @__PURE__ */ (() => {
               v.array(v.tuple([v.string(), v.string()])),
               v.description("Mapping of asset names to their streaming open interest caps."),
             ),
+            /** List of delegated function names and their authorized executor addresses. */
+            subDeployers: v.pipe(
+              v.array(
+                v.tuple([
+                  v.string(),
+                  v.array(Address),
+                ]),
+              ),
+              v.description("List of delegated function names and their authorized executor addresses."),
+            ),
           }),
           v.description(" Perpetual dex metadata."),
         ),

package/src/src/api/info/spotClearinghouseState.ts

@@ -2,6 +2,8 @@ import * as v from "valibot";
 import { Address, type DeepImmutable, parser, UnsignedDecimal, UnsignedInteger } from "../_base.js";
 import type { InfoRequestConfig } from "./_types.js";
 
+import { BalanceSchema } from "../_common_schemas.js";
+
 // -------------------- Schemas --------------------
 
 /**
@@ -41,39 +43,7 @@ export const SpotClearinghouseStateResponse = /* @__PURE__ */ (() => {
     v.object({
       /** Balance for each token. */
       balances: v.pipe(
-        v.array(
-          /** Balance for a specific spot token. */
-          v.pipe(
-            v.object({
-              /** Asset symbol. */
-              coin: v.pipe(
-                v.string(),
-                v.description("Asset symbol."),
-              ),
-              /** Unique identifier for the token. */
-              token: v.pipe(
-                UnsignedInteger,
-                v.description("Unique identifier for the token."),
-              ),
-              /** Total balance. */
-              total: v.pipe(
-                UnsignedDecimal,
-                v.description("Total balance."),
-              ),
-              /** Amount on hold. */
-              hold: v.pipe(
-                UnsignedDecimal,
-                v.description("Amount on hold."),
-              ),
-              /** Entry notional value. */
-              entryNtl: v.pipe(
-                UnsignedDecimal,
-                v.description("Entry notional value."),
-              ),
-            }),
-            v.description("Balance for a specific spot token."),
-          ),
-        ),
+        v.array(BalanceSchema),
         v.description("Balance for each token."),
       ),
       /** Escrowed balances. */