@nktkas/hyperliquid 0.24.2 → 0.25.0-beta.1

package/README.md

@@ -396,76 +396,76 @@ class InfoClient {
     });
 
     // Market
-    allMids(): Promise<AllMids>;
-    candleSnapshot(args: CandleSnapshotParameters): Promise<Candle[]>;
-    fundingHistory(args: FundingHistoryParameters): Promise<FundingHistory[]>;
-    l2Book(args: L2BookParameters): Promise<Book>;
+    allMids(params?: AllMidsParameters): Promise<AllMids>;
+    candleSnapshot(params: CandleSnapshotParameters): Promise<Candle[]>;
+    fundingHistory(params: FundingHistoryParameters): Promise<FundingHistory[]>;
+    l2Book(params: L2BookParameters): Promise<Book>;
     liquidatable(): Promise<unknown[]>;
-    marginTable(args: MarginTableParameters): Promise<MarginTable>;
+    marginTable(params: MarginTableParameters): Promise<MarginTable>;
     maxMarketOrderNtls(): Promise<[number, string][]>;
-    meta(): Promise<PerpsMeta>;
-    metaAndAssetCtxs(): Promise<PerpsMetaAndAssetCtxs>;
+    meta(params?: MetaParameters): Promise<PerpsMeta>;
+    metaAndAssetCtxs(params?: MetaAndAssetCtxsParameters): Promise<PerpsMetaAndAssetCtxs>;
     perpDeployAuctionStatus(): Promise<DeployAuctionStatus>;
     perpDexs(): Promise<(PerpDex | null)[]>;
-    perpsAtOpenInterestCap(): Promise<string[]>;
+    perpsAtOpenInterestCap(params?: PerpsAtOpenInterestCapParameters): Promise<string[]>;
     predictedFundings(): Promise<PredictedFunding[]>;
-    spotDeployState(args: SpotDeployStateParameters): Promise<SpotDeployState>;
+    spotDeployState(params: SpotDeployStateParameters): Promise<SpotDeployState>;
     spotMeta(): Promise<SpotMeta>;
     spotMetaAndAssetCtxs(): Promise<SpotMetaAndAssetCtxs>;
     spotPairDeployAuctionStatus(): Promise<DeployAuctionStatus>;
-    tokenDetails(args: TokenDetailsParameters): Promise<TokenDetails>;
+    tokenDetails(params: TokenDetailsParameters): Promise<TokenDetails>;
 
     // Account
-    activeAssetData(args: ActiveAssetDataParameters): Promise<ActiveAssetData>;
-    clearinghouseState(args: ClearinghouseStateParameters): Promise<PerpsClearinghouseState>;
-    extraAgents(args: ExtraAgentsParameters): Promise<ExtraAgent[]>;
-    isVip(args: IsVipParameters): Promise<boolean>;
-    legalCheck(args: LegalCheckParameters): Promise<LegalCheck>;
-    maxBuilderFee(args: MaxBuilderFeeParameters): Promise<number>;
-    portfolio(args: PortfolioParameters): Promise<PortfolioPeriods>;
-    preTransferCheck(args: PreTransferCheckParameters): Promise<PreTransferCheck>;
-    referral(args: ReferralParameters): Promise<Referral>;
-    spotClearinghouseState(args: SpotClearinghouseStateParameters): Promise<SpotClearinghouseState>;
-    subAccounts(args: SubAccountsParameters): Promise<SubAccount[] | null>;
-    userFees(args: UserFeesParameters): Promise<UserFees>;
-    userFunding(args: UserFundingParameters): Promise<UserFundingUpdate[]>;
-    userNonFundingLedgerUpdates(args: UserNonFundingLedgerUpdatesParameters): Promise<UserNonFundingLedgerUpdate[]>;
-    userRateLimit(args: UserRateLimitParameters): Promise<UserRateLimit>;
-    userRole(args: UserRoleParameters): Promise<UserRole>;
-    userToMultiSigSigners(args: UserToMultiSigSignersParameters): Promise<MultiSigSigners | null>;
+    activeAssetData(params: ActiveAssetDataParameters): Promise<ActiveAssetData>;
+    clearinghouseState(params: ClearinghouseStateParameters): Promise<PerpsClearinghouseState>;
+    extraAgents(params: ExtraAgentsParameters): Promise<ExtraAgent[]>;
+    isVip(params: IsVipParameters): Promise<boolean | null>;
+    legalCheck(params: LegalCheckParameters): Promise<LegalCheck>;
+    maxBuilderFee(params: MaxBuilderFeeParameters): Promise<number>;
+    portfolio(params: PortfolioParameters): Promise<PortfolioPeriods>;
+    preTransferCheck(params: PreTransferCheckParameters): Promise<PreTransferCheck>;
+    referral(params: ReferralParameters): Promise<Referral>;
+    spotClearinghouseState(params: SpotClearinghouseStateParameters): Promise<SpotClearinghouseState>;
+    subAccounts(params: SubAccountsParameters): Promise<SubAccount[] | null>;
+    userFees(params: UserFeesParameters): Promise<UserFees>;
+    userFunding(params: UserFundingParameters): Promise<UserFundingUpdate[]>;
+    userNonFundingLedgerUpdates(params: UserNonFundingLedgerUpdatesParameters): Promise<UserNonFundingLedgerUpdate[]>;
+    userRateLimit(params: UserRateLimitParameters): Promise<UserRateLimit>;
+    userRole(params: UserRoleParameters): Promise<UserRole>;
+    userToMultiSigSigners(params: UserToMultiSigSignersParameters): Promise<MultiSigSigners | null>;
 
     // Order
-    frontendOpenOrders(args: FrontendOpenOrdersParameters): Promise<FrontendOrder[]>;
-    historicalOrders(args: HistoricalOrdersParameters): Promise<OrderStatus<FrontendOrder>[]>;
-    openOrders(args: OpenOrdersParameters): Promise<Order[]>;
-    orderStatus(args: OrderStatusParameters): Promise<OrderLookup>;
-    twapHistory(args: TwapHistoryParameters): Promise<TwapHistory[]>;
-    userFills(args: UserFillsParameters): Promise<Fill[]>;
-    userFillsByTime(args: UserFillsByTimeParameters): Promise<Fill[]>;
-    userTwapSliceFills(args: UserTwapSliceFillsParameters): Promise<TwapSliceFill[]>;
-    userTwapSliceFillsByTime(args: UserTwapSliceFillsByTimeParameters): Promise<TwapSliceFill[]>;
+    frontendOpenOrders(params: FrontendOpenOrdersParameters): Promise<FrontendOrder[]>;
+    historicalOrders(params: HistoricalOrdersParameters): Promise<FrontendOrderStatus[]>;
+    openOrders(params: OpenOrdersParameters): Promise<Order[]>;
+    orderStatus(params: OrderStatusParameters): Promise<OrderLookup>;
+    twapHistory(params: TwapHistoryParameters): Promise<TwapHistory[]>;
+    userFills(params: UserFillsParameters): Promise<Fill[]>;
+    userFillsByTime(params: UserFillsByTimeParameters): Promise<Fill[]>;
+    userTwapSliceFills(params: UserTwapSliceFillsParameters): Promise<TwapSliceFill[]>;
+    userTwapSliceFillsByTime(params: UserTwapSliceFillsByTimeParameters): Promise<TwapSliceFill[]>;
 
     // Validator
-    delegations(args: DelegationsParameters): Promise<Delegation[]>;
-    delegatorHistory(args: DelegatorHistoryParameters): Promise<DelegatorUpdate[]>;
-    delegatorRewards(args: DelegatorRewardsParameters): Promise<DelegatorReward[]>;
-    delegatorSummary(args: DelegatorSummaryParameters): Promise<DelegatorSummary>;
+    delegations(params: DelegationsParameters): Promise<Delegation[]>;
+    delegatorHistory(params: DelegatorHistoryParameters): Promise<DelegatorUpdate[]>;
+    delegatorRewards(params: DelegatorRewardsParameters): Promise<DelegatorReward[]>;
+    delegatorSummary(params: DelegatorSummaryParameters): Promise<DelegatorSummary>;
     validatorL1Votes(): Promise<unknown[]>;
     validatorSummaries(): Promise<ValidatorSummary[]>;
 
     // Vault
-    leadingVaults(args: LeadingVaultsParameters): Promise<VaultLeading[]>;
-    userVaultEquities(args: UserVaultEquitiesParameters): Promise<VaultEquity[]>;
-    vaultDetails(args: VaultDetailsParameters): Promise<VaultDetails | null>;
+    leadingVaults(params: LeadingVaultsParameters): Promise<VaultLeading[]>;
+    userVaultEquities(params: UserVaultEquitiesParameters): Promise<VaultEquity[]>;
+    vaultDetails(params: VaultDetailsParameters): Promise<VaultDetails | null>;
     vaultSummaries(): Promise<VaultSummary[]>;
 
     // Server
     exchangeStatus(): Promise<ExchangeStatus>;
 
     // Explorer (RPC endpoint)
-    blockDetails(args: BlockDetailsParameters): Promise<BlockDetails>;
-    txDetails(args: TxDetailsParameters): Promise<TxDetails>;
-    userDetails(args: UserDetailsParameters): Promise<TxDetails[]>;
+    blockDetails(params: BlockDetailsParameters): Promise<BlockDetails>;
+    txDetails(params: TxDetailsParameters): Promise<TxDetails>;
+    userDetails(params: UserDetailsParameters): Promise<TxDetails[]>;
 }
 ```
 
@@ -483,62 +483,70 @@ class ExchangeClient {
     });
 
     // Order
-    batchModify(args: BatchModifyParameters): Promise<OrderResponseSuccess>;
-    cancel(args: CancelParameters): Promise<CancelResponseSuccess>;
-    cancelByCloid(args: CancelByCloidParameters): Promise<CancelResponseSuccess>;
-    modify(args: ModifyParameters): Promise<SuccessResponse>;
-    order(args: OrderParameters): Promise<OrderResponseSuccess>;
-    scheduleCancel(args?: ScheduleCancelParameters): Promise<SuccessResponse>;
-    twapCancel(args: TwapCancelParameters): Promise<TwapCancelResponseSuccess>;
-    twapOrder(args: TwapOrderParameters): Promise<TwapOrderResponseSuccess>;
-    updateIsolatedMargin(args: UpdateIsolatedMarginParameters): Promise<SuccessResponse>;
-    updateLeverage(args: UpdateLeverageParameters): Promise<SuccessResponse>;
+    batchModify(params: BatchModifyParameters): Promise<OrderResponseSuccess>;
+    cancel(params: CancelParameters): Promise<CancelResponseSuccess>;
+    cancelByCloid(params: CancelByCloidParameters): Promise<CancelResponseSuccess>;
+    modify(params: ModifyParameters): Promise<SuccessResponse>;
+    order(params: OrderParameters): Promise<OrderResponseSuccess>;
+    scheduleCancel(params?: ScheduleCancelParameters): Promise<SuccessResponse>;
+    twapCancel(params: TwapCancelParameters): Promise<TwapCancelResponseSuccess>;
+    twapOrder(params: TwapOrderParameters): Promise<TwapOrderResponseSuccess>;
+    updateIsolatedMargin(params: UpdateIsolatedMarginParameters): Promise<SuccessResponse>;
+    updateLeverage(params: UpdateLeverageParameters): Promise<SuccessResponse>;
 
     // Account
-    approveAgent(args: ApproveAgentParameters): Promise<SuccessResponse>;
-    approveBuilderFee(args: ApproveBuilderFeeParameters): Promise<SuccessResponse>;
+    approveAgent(params: ApproveAgentParameters): Promise<SuccessResponse>;
+    approveBuilderFee(params: ApproveBuilderFeeParameters): Promise<SuccessResponse>;
     claimRewards(): Promise<SuccessResponse>;
-    createSubAccount(args: CreateSubAccountParameters): Promise<CreateSubAccountResponse>;
-    evmUserModify(args: EvmUserModifyParameters): Promise<SuccessResponse>;
+    createSubAccount(params: CreateSubAccountParameters): Promise<CreateSubAccountResponse>;
+    evmUserModify(params: EvmUserModifyParameters): Promise<SuccessResponse>;
     noop(): Promise<SuccessResponse>;
-    registerReferrer(args: RegisterReferrerParameters): Promise<SuccessResponse>;
-    reserveRequestWeight(args: ReserveRequestWeightParameters): Promise<SuccessResponse>;
-    setDisplayName(args: SetDisplayNameParameters): Promise<SuccessResponse>;
-    setReferrer(args: SetReferrerParameters): Promise<SuccessResponse>;
-    subAccountModify(args: SubAccountModifyParameters): Promise<SuccessResponse>;
-    spotUser(args: SpotUserParameters): Promise<SuccessResponse>;
+    registerReferrer(params: RegisterReferrerParameters): Promise<SuccessResponse>;
+    reserveRequestWeight(params: ReserveRequestWeightParameters): Promise<SuccessResponse>;
+    setDisplayName(params: SetDisplayNameParameters): Promise<SuccessResponse>;
+    setReferrer(params: SetReferrerParameters): Promise<SuccessResponse>;
+    subAccountModify(params: SubAccountModifyParameters): Promise<SuccessResponse>;
+    spotUser(params: SpotUserParameters): Promise<SuccessResponse>;
 
     // Transfer
-    sendAsset(args: SendAssetParameters): Promise<SuccessResponse>;
-    spotSend(args: SpotSendParameters): Promise<SuccessResponse>;
-    subAccountSpotTransfer(args: SubAccountSpotTransferParameters): Promise<SuccessResponse>;
-    subAccountTransfer(args: SubAccountTransferParameters): Promise<SuccessResponse>;
-    usdClassTransfer(args: UsdClassTransferParameters): Promise<SuccessResponse>;
-    usdSend(args: UsdSendParameters): Promise<SuccessResponse>;
-    withdraw3(args: Withdraw3Parameters): Promise<SuccessResponse>;
+    sendAsset(params: SendAssetParameters): Promise<SuccessResponse>;
+    spotSend(params: SpotSendParameters): Promise<SuccessResponse>;
+    subAccountSpotTransfer(params: SubAccountSpotTransferParameters): Promise<SuccessResponse>;
+    subAccountTransfer(params: SubAccountTransferParameters): Promise<SuccessResponse>;
+    usdClassTransfer(params: UsdClassTransferParameters): Promise<SuccessResponse>;
+    usdSend(params: UsdSendParameters): Promise<SuccessResponse>;
+    withdraw3(params: Withdraw3Parameters): Promise<SuccessResponse>;
 
     // Staking
-    cDeposit(args: CDepositParameters): Promise<SuccessResponse>;
-    cWithdraw(args: CWithdrawParameters): Promise<SuccessResponse>;
-    tokenDelegate(args: TokenDelegateParameters): Promise<SuccessResponse>;
+    cDeposit(params: CDepositParameters): Promise<SuccessResponse>;
+    cWithdraw(params: CWithdrawParameters): Promise<SuccessResponse>;
+    tokenDelegate(params: TokenDelegateParameters): Promise<SuccessResponse>;
 
     // Market
-    perpDeploy(args: PerpDeployParameters): Promise<SuccessResponse>;
-    spotDeploy(args: SpotDeployParameters): Promise<SuccessResponse>;
+    perpDeploy(params: PerpDeployParameters): Promise<SuccessResponse>;
+    spotDeploy(params: SpotDeployParameters): Promise<SuccessResponse>;
 
     // Vault
-    createVault(args: CreateVaultParameters): Promise<CreateVaultResponse>;
-    vaultDistribute(args: VaultDistributeParameters): Promise<SuccessResponse>;
-    vaultModify(args: VaultModifyParameters): Promise<SuccessResponse>;
-    vaultTransfer(args: VaultTransferParameters): Promise<SuccessResponse>;
+    createVault(params: CreateVaultParameters): Promise<CreateVaultResponse>;
+    vaultDistribute(params: VaultDistributeParameters): Promise<SuccessResponse>;
+    vaultModify(params: VaultModifyParameters): Promise<SuccessResponse>;
+    vaultTransfer(params: VaultTransferParameters): Promise<SuccessResponse>;
 
     // Multi-Sign
-    convertToMultiSigUser(args: ConvertToMultiSigUserParameters): Promise<SuccessResponse>;
-    multiSig(args: MultiSigParameters): Promise<BaseExchangeResponse>;
+    convertToMultiSigUser(params: ConvertToMultiSigUserParameters): Promise<SuccessResponse>;
+    multiSig(params: MultiSigParameters): Promise<
+        | SuccessResponse
+        | CancelSuccessResponse
+        | CreateSubAccountResponse
+        | CreateVaultResponse
+        | OrderSuccessResponse
+        | TwapOrderSuccessResponse
+        | TwapCancelSuccessResponse
+    >;
 
     // Validator
-    cSignerAction(args: CSignerActionParameters): Promise<SuccessResponse>;
-    cValidatorAction(args: CValidatorActionParameters): Promise<SuccessResponse>;
+    cSignerAction(params: CSignerActionParameters): Promise<SuccessResponse>;
+    cValidatorAction(params: CValidatorActionParameters): Promise<SuccessResponse>;
 }
 ```
 
@@ -552,26 +560,29 @@ class SubscriptionClient {
     });
 
     // Market
-    activeAssetCtx(args: EventActiveAssetCtxParameters, listener: (data: WsActiveAssetCtx | WsActiveSpotAssetCtx) => void): Promise<Subscription>;
-    allMids(listener: (data: WsAllMids) => void): Promise<Subscription>;
-    bbo(args: EventBboParameters, listener: (data: WsBbo) => void): Promise<Subscription>;
-    candle(args: EventCandleParameters, listener: (data: Candle) => void): Promise<Subscription>;
-    l2Book(args: EventL2BookParameters, listener: (data: Book) => void): Promise<Subscription>;
-    trades(args: EventTradesParameters, listener: (data: WsTrade[]) => void): Promise<Subscription>;
+    activeAssetCtx(params: WsActiveAssetCtxParameters, listener: (data: WsActiveAssetCtx | WsActiveSpotAssetCtx) => void): Promise<Subscription>;
+    allMids(params?: WsAllMidsParameters, listener: (data: WsAllMids) => void): Promise<Subscription>;
+    assetCtxs(params?: WsAssetCtxsParameters, listener: (data: WsAssetCtxs) => void): Promise<Subscription>;
+    bbo(params: WsBboParameters, listener: (data: WsBbo) => void): Promise<Subscription>;
+    candle(params: WsCandleParameters, listener: (data: Candle) => void): Promise<Subscription>;
+    l2Book(params: WsL2BookParameters, listener: (data: Book) => void): Promise<Subscription>;
+    trades(params: WsTradesParameters, listener: (data: WsTrade[]) => void): Promise<Subscription>;
 
     // Account
-    activeAssetData(args: EventActiveAssetDataParameters, listener: (data: ActiveAssetData) => void): Promise<Subscription>;
-    notification(args: EventNotificationParameters, listener: (data: WsNotification) => void): Promise<Subscription>;
-    userEvents(args: EventUserEventsParameters, listener: (data: WsUserEvent) => void): Promise<Subscription>;
-    userFundings(args: EventUserFundingsParameters, listener: (data: WsUserFundings) => void): Promise<Subscription>;
-    userNonFundingLedgerUpdates(args: EventUserNonFundingLedgerUpdatesParameters, listener: (data: WsUserNonFundingLedgerUpdates) => void): Promise<Subscription>;
-    webData2(args: EventWebData2Parameters, listener: (data: WsWebData2) => void): Promise<Subscription>;
+    activeAssetData(params: WsActiveAssetDataParameters, listener: (data: ActiveAssetData) => void): Promise<Subscription>;
+    clearinghouseState(params: WsClearinghouseStateParameters, listener: (data: WsClearinghouseState) => void): Promise<Subscription>;
+    notification(params: WsNotificationParameters, listener: (data: WsNotification) => void): Promise<Subscription>;
+    userEvents(params: WsUserEventsParameters, listener: (data: WsUserEvent) => void): Promise<Subscription>;
+    userFundings(params: WsUserFundingsParameters, listener: (data: WsUserFundings) => void): Promise<Subscription>;
+    userNonFundingLedgerUpdates(params: WsUserNonFundingLedgerUpdatesParameters, listener: (data: WsUserNonFundingLedgerUpdates) => void): Promise<Subscription>;
+    webData2(params: WsWebData2Parameters, listener: (data: WsWebData2) => void): Promise<Subscription>;
 
     // Order
-    orderUpdates(args: EventOrderUpdatesParameters, listener: (data: OrderStatus<Order>[]) => void): Promise<Subscription>;
-    userFills(args: EventUserFillsParameters, listener: (data: WsUserFills) => void): Promise<Subscription>;
-    userTwapHistory(args: EventUserTwapHistory, listener: (data: WsUserTwapHistory) => void): Promise<Subscription>;
-    userTwapSliceFills(args: EventUserTwapSliceFills, listener: (data: WsUserTwapSliceFills) => void): Promise<Subscription>;
+    openOrders(params: WsOpenOrdersParameters, listener: (data: WsOpenOrders) => void): Promise<Subscription>;
+    orderUpdates(params: WsOrderUpdatesParameters, listener: (data: OrderStatus[]) => void): Promise<Subscription>;
+    userFills(params: WsUserFillsParameters, listener: (data: WsUserFills) => void): Promise<Subscription>;
+    userTwapHistory(params: WsUserTwapHistoryParameters, listener: (data: WsUserTwapHistory) => void): Promise<Subscription>;
+    userTwapSliceFills(params: WsUserTwapSliceFillsParameters, listener: (data: WsUserTwapSliceFills) => void): Promise<Subscription>;
 
     // Explorer (RPC endpoint)
     explorerBlock(listener: (data: WsBlockDetails[]) => void): Promise<Subscription>;
@@ -670,20 +681,90 @@ class WebSocketTransport {
 
 ## Additional Import Points
 
-### `/types`
+### `/schemas`
 
-The import point gives access to all request/response types associated with Hyperliquid API.
+This module provides [valibot](https://valibot.dev) schemas for validating, formatting, and inferring types for data
+used in the Hyperliquid API.
+
+```ts
+import { OrderRequest, parser } from "@nktkas/hyperliquid/schemas";
+//       ^^^^^^^^^^^^
+//       both a valibot schema and a typescript type
+
+const action = {
+    type: "order",
+    orders: [{
+        a: 0,
+        b: true,
+        p: "50000",
+        s: "0.1",
+        r: false,
+        t: { limit: { tif: "Gtc" } },
+    }],
+    grouping: "na",
+} satisfies OrderRequest["action"]; // can be used as type
+
+//                             or as valibot schema
+//                             ⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄
+const validatedAction = parser(OrderRequest.entries.action)(action);
+//                      ^^^^^^
+//                      validates, formats, sorts object keys for correct signature generation
+//                      and returns typed data
+```
+
+Also valibot schema can be converted to JSON Schema:
+
+```ts
+import { OrderRequest } from "@nktkas/hyperliquid/schemas";
+import { toJsonSchema } from "@valibot/to-json-schema";
+
+const schema = toJsonSchema(OrderRequest, { errorMode: "ignore" });
+
+console.log(JSON.stringify(schema, null, 2));
+// {
+//   "$schema": "http://json-schema.org/draft-07/schema#",
+//   "type": "object",
+//   "properties": {
+//     "action": {
+//       "type": "object",
+//       "properties": {
+//         "type": { "const": "order" },
+//         "orders": { "type": "array", "items": {...} },
+//         "grouping": { "anyOf": [...] },
+//         "builder": { "type": "object", ... }
+//       },
+//       "required": ["type", "orders", "grouping"]
+//     },
+//     "nonce": { "type": "number" },
+//     "signature": {
+//       "type": "object",
+//       "properties": {
+//         "r": { "type": "string", ... },
+//         "s": { "type": "string", ... },
+//         "v": { "anyOf": [{"const": 27}, {"const": 28}] }
+//       },
+//       "required": ["r", "s", "v"]
+//     },
+//     "vaultAddress": { "type": "string", ... },
+//     "expiresAfter": { "type": "number" }
+//   },
+//   "required": ["action", "nonce", "signature"]
+// }
+```
 
 ### `/signing`
 
-The import point gives access to functions that generate signatures for Hyperliquid API actions.
+This module contains functions for generating Hyperliquid transaction signatures.
 
 #### L1 Action
 
 ```ts
-import { actionSorter, signL1Action } from "@nktkas/hyperliquid/signing";
+import { signL1Action } from "@nktkas/hyperliquid/signing";
+import { CancelRequest, parser } from "@nktkas/hyperliquid/schemas";
+
+const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
 
-const action = actionSorter.cancel({
+const action = parser(CancelRequest.entries.action)({ // for correct signature generation
     type: "cancel",
     cancels: [
         { a: 0, o: 12345 },
@@ -691,17 +772,13 @@ const action = actionSorter.cancel({
 });
 const nonce = Date.now();
 
-const signature = await signL1Action({
-    wallet: "0x...", // `viem`, `ethers`, or private key directly
-    action,
-    nonce,
-});
+const signature = await signL1Action({ wallet: privateKey, action, nonce });
 
 // Send the signed action to the Hyperliquid API
 const response = await fetch("https://api.hyperliquid.xyz/exchange", {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ action, signature, nonce }), // recommended to send the same formatted action
+    body: JSON.stringify({ action, signature, nonce }),
 });
 const body = await response.json();
 ```
@@ -709,9 +786,12 @@ const body = await response.json();
 #### User Signed Action
 
 ```ts
-import { actionSorter, signUserSignedAction, userSignedActionEip712Types } from "@nktkas/hyperliquid/signing";
+import { signUserSignedAction, userSignedActionEip712Types } from "@nktkas/hyperliquid/signing";
+import { ApproveAgentRequest, parser } from "@nktkas/hyperliquid/schemas";
 
-const action = actionSorter.approveAgent({
+const privateKey = "0x..."; // `viem`, `ethers`, or private key directly
+
+const action = parser(ApproveAgentRequest.entries.action)({ // for correct signature generation
     type: "approveAgent",
     signatureChainId: "0x66eee",
     hyperliquidChain: "Mainnet",
@@ -721,7 +801,7 @@ const action = actionSorter.approveAgent({
 });
 
 const signature = await signUserSignedAction({
-    wallet: "0x...", // `viem`, `ethers`, or private key directly
+    wallet: privateKey,
     action,
     types: userSignedActionEip712Types[action.type],
 });
@@ -730,7 +810,7 @@ const signature = await signUserSignedAction({
 const response = await fetch("https://api.hyperliquid.xyz/exchange", {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ action, signature, nonce: action.nonce }), // recommended to send the same formatted action
+    body: JSON.stringify({ action, signature, nonce: action.nonce }),
 });
 const body = await response.json();
 ```

package/esm/mod.d.ts

@@ -1,4 +1,4 @@
-export * from "./src/base.js";
+export * from "./src/errors.js";
 export * from "./src/transports/base.js";
 export type { AbstractWallet } from "./src/signing/mod.js";
 export * from "./src/clients/exchange.js";
@@ -7,14 +7,14 @@ export * from "./src/clients/multiSign.js";
 export * from "./src/clients/subscription.js";
 export * from "./src/transports/http/http_transport.js";
 export * from "./src/transports/websocket/websocket_transport.js";
-export type { OrderParams, Signature } from "./src/types/exchange/requests.js";
-export type * from "./src/types/exchange/responses.js";
-export type * from "./src/types/explorer/responses.js";
-export type * from "./src/types/info/accounts.js";
-export type * from "./src/types/info/assets.js";
-export type * from "./src/types/info/validators.js";
-export type * from "./src/types/info/markets.js";
-export type * from "./src/types/info/orders.js";
-export type * from "./src/types/info/vaults.js";
-export type * from "./src/types/subscriptions/responses.js";
+export type { OrderParams, Signature } from "./src/schemas/exchange/requests.js";
+export type * from "./src/schemas/exchange/responses.js";
+export type * from "./src/schemas/explorer/responses.js";
+export type * from "./src/schemas/info/accounts.js";
+export type * from "./src/schemas/info/assets.js";
+export type * from "./src/schemas/info/validators.js";
+export type * from "./src/schemas/info/markets.js";
+export type * from "./src/schemas/info/orders.js";
+export type * from "./src/schemas/info/vaults.js";
+export type * from "./src/schemas/subscriptions/responses.js";
 //# sourceMappingURL=mod.d.ts.map

package/esm/mod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AACA,cAAc,eAAe,CAAC;AAC9B,cAAc,0BAA0B,CAAC;AAGzC,YAAY,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAG3D,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,+BAA+B,CAAC;AAG9C,cAAc,yCAAyC,CAAC;AACxD,cAAc,mDAAmD,CAAC;AAGlE,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAC/E,mBAAmB,mCAAmC,CAAC;AACvD,mBAAmB,mCAAmC,CAAC;AACvD,mBAAmB,8BAA8B,CAAC;AAClD,mBAAmB,4BAA4B,CAAC;AAChD,mBAAmB,gCAAgC,CAAC;AACpD,mBAAmB,6BAA6B,CAAC;AACjD,mBAAmB,4BAA4B,CAAC;AAChD,mBAAmB,4BAA4B,CAAC;AAChD,mBAAmB,wCAAwC,CAAC"}
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AACA,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AAGzC,YAAY,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAG3D,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,+BAA+B,CAAC;AAG9C,cAAc,yCAAyC,CAAC;AACxD,cAAc,mDAAmD,CAAC;AAGlE,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,oCAAoC,CAAC;AACjF,mBAAmB,qCAAqC,CAAC;AACzD,mBAAmB,qCAAqC,CAAC;AACzD,mBAAmB,gCAAgC,CAAC;AACpD,mBAAmB,8BAA8B,CAAC;AAClD,mBAAmB,kCAAkC,CAAC;AACtD,mBAAmB,+BAA+B,CAAC;AACnD,mBAAmB,8BAA8B,CAAC;AAClD,mBAAmB,8BAA8B,CAAC;AAClD,mBAAmB,0CAA0C,CAAC"}

package/esm/mod.js

@@ -1,5 +1,5 @@
 // Base interfaces
-export * from "./src/base.js";
+export * from "./src/errors.js";
 export * from "./src/transports/base.js";
 // Clients
 export * from "./src/clients/exchange.js";

package/esm/src/clients/exchange.d.ts

@@ -1,7 +1,7 @@
-import { HyperliquidError } from "../base.js";
+import { HyperliquidError } from "../errors.js";
 import type { IRequestTransport } from "../transports/base.js";
-import type { ApproveAgentRequest, ApproveBuilderFeeRequest, BatchModifyRequest, CancelByCloidRequest, CancelRequest, CancelResponse, CancelSuccessResponse, CDepositRequest, ClaimRewardsRequest, ConvertToMultiSigUserRequest, ConvertToMultiSigUserRequestWithoutStringify, CreateSubAccountRequest, CreateSubAccountResponse, CreateVaultRequest, CreateVaultResponse, CSignerActionRequest, CValidatorActionRequest, CWithdrawRequest, ErrorResponse, EvmUserModifyRequest, Hex, ModifyRequest, MultiSigRequest, NoopRequest, OrderRequest, OrderResponse, OrderSuccessResponse, PerpDeployRequest, RegisterReferrerRequest, ReserveRequestWeightRequest, ScheduleCancelRequest, SendAssetRequest, SetDisplayNameRequest, SetReferrerRequest, SpotDeployRequest, SpotSendRequest, SpotUserRequest, SubAccountModifyRequest, SubAccountSpotTransferRequest, SubAccountTransferRequest, SuccessResponse, TokenDelegateRequest, TwapCancelRequest, TwapCancelResponse, TwapCancelSuccessResponse, TwapOrderRequest, TwapOrderResponse, TwapOrderSuccessResponse, UpdateIsolatedMarginRequest, UpdateLeverageRequest, UsdClassTransferRequest, UsdSendRequest, VaultDistributeRequest, VaultModifyRequest, VaultTransferRequest, Withdraw3Request } from "../types/mod.js";
-import { type AbstractWallet, actionSorter, userSignedActionEip712Types } from "../signing/mod.js";
+import { ApproveAgentRequest, ApproveBuilderFeeRequest, BatchModifyRequest, CancelByCloidRequest, CancelRequest, type CancelResponse, type CancelSuccessResponse, CDepositRequest, ClaimRewardsRequest, ConvertToMultiSigUserRequest, type ConvertToMultiSigUserRequestSigners, CreateSubAccountRequest, type CreateSubAccountResponse, CreateVaultRequest, type CreateVaultResponse, CSignerActionRequest, CValidatorActionRequest, CWithdrawRequest, type ErrorResponse, EvmUserModifyRequest, ModifyRequest, MultiSigRequest, NoopRequest, OrderRequest, type OrderResponse, type OrderSuccessResponse, PerpDeployRequest, RegisterReferrerRequest, ReserveRequestWeightRequest, ScheduleCancelRequest, SendAssetRequest, SetDisplayNameRequest, SetReferrerRequest, SpotDeployRequest, SpotSendRequest, SpotUserRequest, SubAccountModifyRequest, SubAccountSpotTransferRequest, SubAccountTransferRequest, type SuccessResponse, TokenDelegateRequest, TwapCancelRequest, type TwapCancelResponse, type TwapCancelSuccessResponse, TwapOrderRequest, type TwapOrderResponse, type TwapOrderSuccessResponse, UpdateIsolatedMarginRequest, UpdateLeverageRequest, UsdClassTransferRequest, UsdSendRequest, VaultDistributeRequest, VaultModifyRequest, VaultTransferRequest, Withdraw3Request } from "../schemas/mod.js";
+import { type AbstractWallet, userSignedActionEip712Types } from "../signing/mod.js";
 type MaybePromise<T> = T | Promise<T>;
 /** @see https://github.com/microsoft/TypeScript/issues/13923#issuecomment-2191862501 */
 type DeepImmutable<T> = {
@@ -20,7 +20,7 @@ export interface ExchangeClientParameters<T extends IRequestTransport = IRequest
      */
     isTestnet?: boolean;
     /** Sets a default vaultAddress to be used if no vaultAddress is explicitly passed to a method. */
-    defaultVaultAddress?: Hex;
+    defaultVaultAddress?: `0x${string}`;
     /** Sets a default expiresAfter to be used if no expiresAfter is explicitly passed to a method. */
     defaultExpiresAfter?: number | (() => MaybePromise<number>);
     /**
@@ -29,7 +29,7 @@ export interface ExchangeClientParameters<T extends IRequestTransport = IRequest
      *
      * Defaults to get chain id from wallet otherwise `0x1`.
      */
-    signatureChainId?: Hex | (() => MaybePromise<Hex>);
+    signatureChainId?: `0x${string}` | (() => MaybePromise<`0x${string}`>);
     /**
      * Function to get the next nonce for signing transactions.
      *
@@ -56,7 +56,10 @@ export type CancelByCloidParameters = ExtractRequestAction<CancelByCloidRequest>
 /** Action parameters for the {@linkcode ExchangeClient.cDeposit} method. */
 export type CDepositParameters = ExtractRequestAction<CDepositRequest>;
 /** Action parameters for the {@linkcode ExchangeClient.convertToMultiSigUser} method. */
-export type ConvertToMultiSigUserParameters = ExtractRequestAction<ConvertToMultiSigUserRequestWithoutStringify>;
+export type ConvertToMultiSigUserParameters = Omit<ExtractRequestAction<ConvertToMultiSigUserRequest>, "signers"> & {
+    /** Signers configuration. */
+    signers: ConvertToMultiSigUserRequestSigners;
+};
 /** Action parameters for the {@linkcode ExchangeClient.createSubAccount} method. */
 export type CreateSubAccountParameters = ExtractRequestAction<CreateSubAccountRequest>;
 /** Action parameters for the {@linkcode ExchangeClient.createVault} method. */
@@ -218,7 +221,7 @@ export type VaultModifyOptions = ExtractRequestOptions<VaultModifyRequest>;
 export type VaultTransferOptions = ExtractRequestOptions<VaultTransferRequest>;
 /** Request options for the {@linkcode ExchangeClient.withdraw3} method. */
 export type Withdraw3Options = ExtractRequestOptions<Withdraw3Request>;
-/** Custom error class for API request errors. */
+/** Thrown when an API request fails. */
 export declare class ApiRequestError extends HyperliquidError {
     response: ErrorResponse | OrderResponse | CancelResponse | TwapOrderResponse | TwapCancelResponse;
     constructor(response: ErrorResponse | OrderResponse | CancelResponse | TwapOrderResponse | TwapCancelResponse);
@@ -232,9 +235,9 @@ export declare class ExchangeClient<T extends IRequestTransport = IRequestTransp
     transport: T;
     wallet: W;
     isTestnet: boolean;
-    defaultVaultAddress?: Hex;
+    defaultVaultAddress?: `0x${string}`;
     defaultExpiresAfter?: number | (() => MaybePromise<number>);
-    signatureChainId: Hex | (() => MaybePromise<Hex>);
+    signatureChainId: `0x${string}` | (() => MaybePromise<`0x${string}`>);
     nonceManager: () => MaybePromise<number>;
     /**
      * Initialises a new instance.
@@ -709,7 +712,8 @@ export declare class ExchangeClient<T extends IRequestTransport = IRequestTransp
      * @example
      * ```ts
      * import * as hl from "@nktkas/hyperliquid";
-     * import { actionSorter, signL1Action } from "@nktkas/hyperliquid/signing";
+     * import { signL1Action } from "@nktkas/hyperliquid/signing";
+     * import { parser, ScheduleCancelRequest } from "@nktkas/hyperliquid/schemas";
      * import { privateKeyToAccount } from "npm:viem/accounts";
      *
      * const wallet = privateKeyToAccount("0x..."); // or any other wallet libraries
@@ -719,7 +723,7 @@ export declare class ExchangeClient<T extends IRequestTransport = IRequestTransp
      * const exchClient = new hl.ExchangeClient({ wallet, transport });
      *
      * const nonce = Date.now();
-     * const action = actionSorter.scheduleCancel({
+     * const action = parser(ScheduleCancelRequest.entries.action)({ // for correct signature generation
      *   type: "scheduleCancel",
      *   time: Date.now() + 10000,
      * });
@@ -733,7 +737,7 @@ export declare class ExchangeClient<T extends IRequestTransport = IRequestTransp
      *   });
      * }));
      *
-     * // or user-signed action
+     * // // or user-signed action
      * // const signatures = await Promise.all(["0x...", "0x..."].map(async (signerPrivKey) => {
      * //   return await signUserSignedAction({
      * //     wallet: signerPrivKey as `0x${string}`,
@@ -1397,21 +1401,28 @@ export declare class ExchangeClient<T extends IRequestTransport = IRequestTransp
      */
     withdraw3(params: DeepImmutable<Withdraw3Parameters>, opts?: Withdraw3Options): Promise<SuccessResponse>;
     protected _executeL1Action<T extends SuccessResponse | CancelSuccessResponse | CreateSubAccountResponse | CreateVaultResponse | OrderSuccessResponse | TwapOrderSuccessResponse | TwapCancelSuccessResponse>(request: {
-        action: Parameters<typeof actionSorter[Exclude<keyof typeof actionSorter, keyof typeof userSignedActionEip712Types>]>[0];
-        vaultAddress?: Hex;
+        action: Record<string, unknown>;
+        vaultAddress?: `0x${string}`;
         expiresAfter: number | undefined;
     }, signal?: AbortSignal): Promise<T>;
     protected _executeUserSignedAction<T extends SuccessResponse | CancelSuccessResponse | CreateSubAccountResponse | CreateVaultResponse | OrderSuccessResponse | TwapOrderSuccessResponse | TwapCancelSuccessResponse>(request: {
-        action: Parameters<typeof actionSorter[Exclude<Extract<keyof typeof actionSorter, keyof typeof userSignedActionEip712Types>, "multiSig">]>[0];
+        action: {
+            type: keyof typeof userSignedActionEip712Types;
+            signatureChainId: `0x${string}`;
+            [key: string]: unknown;
+        };
     }, signal?: AbortSignal): Promise<T>;
     protected _executeMultiSigAction<T extends SuccessResponse | CancelSuccessResponse | CreateSubAccountResponse | CreateVaultResponse | OrderSuccessResponse | TwapOrderSuccessResponse | TwapCancelSuccessResponse>(request: {
-        action: Parameters<typeof actionSorter["multiSig"]>[0];
+        action: {
+            signatureChainId: `0x${string}`;
+            [key: string]: unknown;
+        };
         nonce: number;
-        vaultAddress?: Hex;
+        vaultAddress?: `0x${string}`;
         expiresAfter?: number;
     }, signal?: AbortSignal): Promise<T>;
     protected _getDefaultExpiresAfter(): Promise<number | undefined>;
-    protected _getSignatureChainId(): Promise<Hex>;
+    protected _getSignatureChainId(): Promise<`0x${string}`>;
     protected _getHyperliquidChain(): "Mainnet" | "Testnet";
     protected _validateResponse<T extends SuccessResponse | CancelSuccessResponse | CreateSubAccountResponse | CreateVaultResponse | OrderSuccessResponse | TwapOrderSuccessResponse | TwapCancelSuccessResponse>(response: SuccessResponse | ErrorResponse | CancelResponse | CreateSubAccountResponse | CreateVaultResponse | OrderResponse | TwapOrderResponse | TwapCancelResponse): asserts response is T;
     [Symbol.asyncDispose](): Promise<void>;