@nktkas/hyperliquid 0.13.2 → 0.14.0

package/README.md

@@ -1,8 +1,9 @@
 # Hyperliquid API TypeScript SDK
 
-[![JSR](https://jsr.io/badges/@nktkas/hyperliquid)](https://jsr.io/@nktkas/hyperliquid)
-[![JSR Score](https://jsr.io/badges/@nktkas/hyperliquid/score)](https://jsr.io/@nktkas/hyperliquid)
-[![bundlephobia](https://badgen.net/bundlephobia/minzip/@nktkas/hyperliquid)](https://bundlephobia.com/package/@nktkas/hyperliquid)
+[![NPM](https://img.shields.io/npm/v/@nktkas/hyperliquid?style=flat-square&color=blue)](https://www.npmjs.com/package/@nktkas/hyperliquid)
+[![JSR](https://img.shields.io/jsr/v/@nktkas/hyperliquid?style=flat-square&color=blue)](https://jsr.io/@nktkas/hyperliquid)
+[![Coveralls](https://img.shields.io/coverallsCoverage/github/nktkas/hyperliquid?style=flat-square)](https://coveralls.io/github/nktkas/hyperliquid)
+[![bundlejs](https://img.shields.io/bundlejs/size/@nktkas/hyperliquid?style=flat-square)](https://bundlejs.com/?q=@nktkas/hyperliquid)
 
 Unofficial [Hyperliquid API](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api) SDK for all major JS
 runtimes, written in TypeScript and provided with tests.
@@ -10,12 +11,12 @@ runtimes, written in TypeScript and provided with tests.
 ## Features
 
 - 🖋️ **Typed**: Source code is 100% TypeScript.
-- 🧪 **Tested**: Good code coverage and type validation.
+- 🧪 **Tested**: Good code coverage and type testing.
 - 📦 **Minimal dependencies**: Few small dependencies, standard JS is favored.
 - 🌐 **Cross-Environment Support**: Compatible with all major JS runtimes, including Node.js, Deno, Bun, and browser
   environments.
-- 🔧 **Extensible**: Easily integrates with [viem](https://github.com/wevm/viem) and
-  [ethers](https://github.com/ethers-io/ethers.js).
+- 🔧 **Integratable**: Easy to use with [viem](https://github.com/wevm/viem),
+  [ethers](https://github.com/ethers-io/ethers.js) and web3 wallets.
 - 📚 **Documented**: Comprehensive documentation and usage examples, provided directly in JSDoc annotations within the
   source code.
 
@@ -51,21 +52,15 @@ First, choose and configure your transport layer (more details in the [API Refer
 import * as hl from "@nktkas/hyperliquid";
 
 // HTTP Transport
-const httpTransport = new hl.HttpTransport({ // All options are optional
-    url: "https://api.hyperliquid.xyz", // API base URL for /info, /exchange, /explorer
-    timeout: 10_000, // Request timeout in ms
-});
+const httpTransport = new hl.HttpTransport(); // Accepts optional parameters (e.g. url, timeout, fetchOptions)
 
-// OR WebSocket Transport
-const wsTransport = new hl.WebSocketTransport({ // All options are optional
-    url: "wss://api.hyperliquid.xyz/ws", // WebSocket URL
-    timeout: 10_000, // Request timeout in ms
-});
+// or WebSocket Transport
+const wsTransport = new hl.WebSocketTransport(); // Accepts optional parameters (e.g. url, timeout, keepAlive, reconnect)
 ```
 
 ### Initialize Client
 
-Next, initialize the client with the transport layer (more details in the [API Reference](#clients)):
+Next, initialize a client with the transport layer (more details in the [API Reference](#clients)):
 
 #### Create PublicClient
 
@@ -97,7 +92,10 @@ const ethersClient = new hl.WalletClient({ wallet: ethersWallet, transport });
 // 3. Using external wallet (e.g. MetaMask) via Viem
 const [account] = await window.ethereum.request({ method: "eth_requestAccounts" });
 const externalWallet = createWalletClient({ account, transport: custom(window.ethereum) });
-const metamaskClient = new hl.WalletClient({ wallet: externalWallet, transport });
+const viemMetamaskClient = new hl.WalletClient({ wallet: externalWallet, transport });
+
+// 4. Using external wallet (e.g. MetaMask) via `window.ethereum` directly
+const windowMetamaskClient = new hl.WalletClient({ wallet: window.ethereum, transport });
 ```
 
 #### Create EventClient
@@ -105,8 +103,99 @@ const metamaskClient = new hl.WalletClient({ wallet: externalWallet, transport }
 ```typescript
 import * as hl from "@nktkas/hyperliquid";
 
+const transport = new hl.WebSocketTransport(); // Only WebSocketTransport is supported
+const client = new hl.EventClient({ transport });
+```
+
+### Use Client
+
+Finally, use client methods to interact with the Hyperliquid API (more details in the [API Reference](#clients)):
+
+#### Example of using a public client
+
+```typescript
+import * as hl from "@nktkas/hyperliquid";
+
+const transport = new hl.HttpTransport(); // or WebSocketTransport
+const client = new hl.PublicClient({ transport });
+
+// L2 Book
+const l2Book = await client.l2Book({ coin: "BTC" });
+
+// Account clearinghouse state
+const clearinghouseState = await client.clearinghouseState({ user: "0x..." });
+
+// Open orders
+const openOrders = await client.openOrders({ user: "0x..." });
+```
+
+#### Example of using a wallet client
+
+```typescript
+import * as hl from "@nktkas/hyperliquid";
+import { privateKeyToAccount } from "viem/accounts";
+
+const account = privateKeyToAccount("0x...");
+const transport = new hl.HttpTransport();
+const client = new hl.WalletClient({ wallet: account, transport });
+
+// Place an orders
+const result = await client.order({
+    orders: [{
+        a: 0, // Asset index
+        b: true, // Buy order
+        p: "30000", // Price
+        s: "0.1", // Size
+        r: false, // Not reduce-only
+        t: {
+            limit: {
+                tif: "Gtc", // Good-til-cancelled
+            },
+        },
+    }],
+    grouping: "na", // No grouping
+});
+
+// Approve an agent
+const result = await client.approveAgent({
+    agentAddress: "0x...",
+    agentName: "agentName",
+});
+
+// Withdraw funds
+const result = await client.withdraw3({
+    destination: account.address, // Withdraw funds to your address
+    amount: "100", // 100 USD
+});
+```
+
+#### Example of using an event client
+
+```typescript
+import * as hl from "@nktkas/hyperliquid";
+
 const transport = new hl.WebSocketTransport();
 const client = new hl.EventClient({ transport });
+
+// L2 Book updates
+// Promise is resolved when the subscription is set up
+const sub = await client.l2Book({ coin: "BTC" }, (data) => {
+    console.log(data);
+});
+// Later, you can unsubscribe from receiving events
+await sub.unsubscribe();
+
+// User fills
+const sub = await client.userFills({ user: "0x..." }, (data) => {
+    console.log(data);
+});
+await sub.unsubscribe();
+
+// Explorer block updates
+const sub = await client.explorerBlock((data) => {
+    console.log(data);
+});
+await sub.unsubscribe();
 ```
 
 ## API Reference
@@ -126,20 +215,18 @@ A Public Client which provides access to
 The Public Client class sets up with a given [Transport](#transports).
 
 ```typescript
-interface PublicClientParameters<T extends IRequestTransport = IRequestTransport> {
-    transport: T; // HttpTransport or WebSocketTransport
-}
-
-class PublicClient<T extends IRESTTransport> {
-    constructor(args: PublicClientParameters<T>);
+class PublicClient {
+    constructor(args: {
+        transport: HttpTransport | WebSocketTransport;
+    });
 
     // Market
     allMids(): Promise<AllMids>;
-    candleSnapshot(args: CandleSnapshotParameters): Promise<CandleSnapshot[]>;
+    candleSnapshot(args: CandleSnapshotParameters): Promise<Candle[]>;
     fundingHistory(args: FundingHistoryParameters): Promise<FundingHistory[]>;
-    l2Book(args: L2BookParameters): Promise<L2Book>;
-    meta(): Promise<Meta>;
-    metaAndAssetCtxs(): Promise<MetaAndAssetCtxs>;
+    l2Book(args: L2BookParameters): Promise<Book>;
+    meta(): Promise<PerpsMeta>;
+    metaAndAssetCtxs(): Promise<PerpsMetaAndAssetCtxs>;
     perpsAtOpenInterestCap(): Promise<string[]>;
     predictedFundings(): Promise<PredictedFunding[]>;
     spotDeployState(args: SpotDeployStateParameters): Promise<SpotDeployState>;
@@ -148,28 +235,30 @@ class PublicClient<T extends IRESTTransport> {
     tokenDetails(args: TokenDetailsParameters): Promise<TokenDetails>;
 
     // Account
-    clearinghouseState(args: ClearinghouseStateParameters): Promise<ClearinghouseState>;
+    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>;
     referral(args: ReferralParameters): Promise<Referral>;
     spotClearinghouseState(args: SpotClearinghouseStateParameters): Promise<SpotClearinghouseState>;
-    subAccounts(args: SubAccountsParameters): Promise<SubAccount[]>;
+    subAccounts(args: SubAccountsParameters): Promise<SubAccount[] | null>;
     userFees(args: UserFeesParameters): Promise<UserFees>;
-    userFunding(args: UserFundingParameters): Promise<UserFunding[]>;
-    userNonFundingLedgerUpdates(args: UserNonFundingLedgerUpdatesParameters): Promise<UserNonFundingLedgerUpdates[]>;
+    userFunding(args: UserFundingParameters): Promise<UserFundingUpdate[]>;
+    userNonFundingLedgerUpdates(args: UserNonFundingLedgerUpdatesParameters): Promise<UserNonFundingLedgerUpdate[]>;
     userRateLimit(args: UserRateLimitParameters): Promise<UserRateLimit>;
     userRole(args: UserRoleParameters): Promise<UserRole>;
 
     // Order
-    frontendOpenOrders(args: FrontendOpenOrdersParameters): Promise<FrontendOpenOrder[]>;
-    historicalOrders(args: HistoricalOrdersParameters): Promise<OrderStatus[]>;
-    openOrders(args: OpenOrdersParameters): Promise<OpenOrder[]>;
-    orderStatus(args: OrderStatusParameters): Promise<OrderStatusResponse>;
-    twapHistory(args: TwapHistoryParameters): Promise<TwapHistory>;
-    userFills(args: UserFillsParameters): Promise<UserFill[]>;
-    userFillsByTime(args: UserFillsByTimeParameters): Promise<UserFill[]>;
-    userTwapSliceFills(args: UserTwapSliceFillsParameters): Promise<UserTwapSliceFill[]>;
+    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[]>;
 
     // Staking
     delegations(args: DelegationsParameters): Promise<Delegation[]>;
@@ -179,7 +268,7 @@ class PublicClient<T extends IRESTTransport> {
     validatorSummaries(): Promise<ValidatorSummary[]>;
 
     // Vault
-    userVaultEquities(args: UserVaultEquitiesParameters): Promise<UserVaultEquity[]>;
+    userVaultEquities(args: UserVaultEquitiesParameters): Promise<VaultEquity[]>;
     vaultDetails(args: VaultDetailsParameters): Promise<VaultDetails | null>;
     vaultSummaries(): Promise<VaultSummary[]>;
 
@@ -201,21 +290,18 @@ The Wallet Client class sets up with a given [Transport](#transports) and a wall
 [Ethers Wallet](https://docs.ethers.org/v6/api/providers/#Signer).
 
 ```typescript
-interface WalletClientParameters<
-    T extends ISubscriptionTransport,
-    W extends AbstractViemWalletClient | AbstractEthersSigner | AbstractEthersV5Signer,
-> {
-    transport: T; // HttpTransport or WebSocketTransport
-    wallet: W; // viem, ethers, or ethers v5
-    isTestnet?: boolean; // Whether to use testnet API (default: false)
-    defaultVaultAddress?: Hex; // Vault address used by default if not provided in method call
-}
-
-class WalletClient<
-    T extends IRESTTransport,
-    W extends AbstractViemWalletClient | AbstractEthersSigner | AbstractEthersV5Signer,
-> {
-    constructor(args: WalletClientParameters<T, W>);
+class WalletClient {
+    constructor(args: {
+        transport: HttpTransport | WebSocketTransport;
+        wallet:
+            | AbstractViemWalletClient // viem
+            | AbstractExtendedViemWalletClient // extended viem (e.g. privy)
+            | AbstractEthersSigner // ethers
+            | AbstractEthersV5Signer // ethers v5
+            | AbstractWindowEthereum; // window.ethereum (EIP-1193) directly
+        isTestnet?: boolean; // Whether to use testnet API (default: false)
+        defaultVaultAddress?: Hex; // Vault address used by default if not provided in method call
+    });
 
     // Order
     batchModify(args: BatchModifyParameters): Promise<OrderResponseSuccess>;
@@ -232,21 +318,30 @@ class WalletClient<
     // Account
     approveAgent(args: ApproveAgentParameters): Promise<SuccessResponse>;
     approveBuilderFee(args: ApproveBuilderFeeParameters): Promise<SuccessResponse>;
+    claimRewards(args: ClaimRewardsParameters): Promise<SuccessResponse>;
     createSubAccount(args: CreateSubAccountParameters): Promise<CreateSubAccountResponse>;
+    evmUserModify(args: EvmUserModifyParameters): Promise<SuccessResponse>;
+    setDisplayName(args: SetDisplayNameParameters): Promise<SuccessResponse>;
     setReferrer(args: SetReferrerParameters): Promise<SuccessResponse>;
+    spotUser(args: SpotUserParameters): Promise<SuccessResponse>;
 
     // Transfers & Withdrawals
     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>;
-    vaultTransfer(args: VaultTransferParameters): Promise<SuccessResponse>;
     withdraw3(args: Withdraw3Parameters): Promise<SuccessResponse>;
 
     // Staking
     cDeposit(args: CDepositParameters): Promise<SuccessResponse>;
     cWithdraw(args: CWithdrawParameters): Promise<SuccessResponse>;
     tokenDelegate(args: TokenDelegateParameters): Promise<SuccessResponse>;
+
+    // Vault
+    vaultDistribute(args: VaultDistributeParameters): Promise<SuccessResponse>;
+    vaultModify(args: VaultModifyParameters): Promise<SuccessResponse>;
+    vaultTransfer(args: VaultTransferParameters): Promise<SuccessResponse>;
 }
 ```
 
@@ -260,12 +355,10 @@ The Event Client class sets up with a given [WebSocket Transport](#websocket-tra
 
 <!-- deno-fmt-ignore-start -->
 ```typescript
-interface EventClientParameters<T extends ISubscriptionTransport> {
-    transport: T; // WebSocketTransport
-}
-
-class EventClient<T extends ISubscriptionTransport> {
-    constructor(args: EventClientParameters<T>);
+class EventClient {
+    constructor(args: {
+        transport: WebSocketTransport;
+    });
 
     // Market
     activeAssetCtx(args: EventActiveAssetCtxParameters, listener: (data: WsActiveAssetCtx | WsActiveSpotAssetCtx) => void): Promise<Subscription>;
@@ -308,19 +401,17 @@ A HTTP Transport that executes requests via a [fetch](https://developer.mozilla.
 API.
 
 ```typescript
-class HttpTransport implements IRequestTransport, HttpTransportOptions {
-    constructor(options?: HttpTransportOptions);
+class HttpTransport {
+    constructor(options?: {
+        url?: string | URL; // Base URL for API endpoints (default: "https://api.hyperliquid.xyz")
+        timeout?: number; // Request timeout in ms (default: 10_000)
+        fetchOptions?: RequestInit; // A custom fetch options
+        onRequest?: (request: Request) => MaybePromise<Request | void | null | undefined>; // A callback before request is sent
+        onResponse?: (response: Response) => MaybePromise<Response | void | null | undefined>; // A callback after response is received
+    });
 
     request(endpoint: "info" | "action" | "explorer", payload: unknown, signal?: AbortSignal): Promise<unknown>;
 }
-
-interface HttpTransportOptions {
-    url?: string | URL; // Base URL for API endpoints (default: "https://api.hyperliquid.xyz")
-    timeout?: number; // Request timeout in ms (default: 10_000)
-    fetchOptions?: RequestInit; // A custom fetch options
-    onRequest?: (request: Request) => MaybePromise<Request | void | null | undefined>; // A callback before request is sent
-    onResponse?: (response: Response) => MaybePromise<Response | void | null | undefined>; // A callback after response is received
-}
 ```
 
 #### WebSocket Transport
@@ -329,8 +420,21 @@ A WebSocket Transport that executes requests and subscribes to events via a
 [WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket) connection.
 
 ```typescript
-class WebSocketTransport implements IRESTTransport, ISubscriptionTransport {
-    constructor(options?: WebSocketTransportOptions);
+class WebSocketTransport {
+    constructor(options?: {
+        url?: string | URL; // WebSocket URL (default: "wss://api.hyperliquid.xyz/ws")
+        timeout?: number; // Request timeout in ms (default: 10_000)
+        keepAlive?: { // Keep-alive configuration
+            interval?: number; // Ping interval in ms (default: 20_000)
+        };
+        reconnect?: { // Reconnection policy configuration for closed connections
+            maxRetries?: number; // Maximum number of reconnection attempts (default: 3)
+            connectionTimeout?: number; // Connection timeout in ms (default: 10_000)
+            connectionDelay?: number | ((attempt: number) => number | Promise<number>); // Delay between reconnection (default: Exponential backoff (max 10s))
+            shouldReconnect?: (event: CloseEvent) => boolean | Promise<boolean>; // Custom reconnection logic (default: Always reconnect)
+            messageBuffer?: MessageBufferStrategy; // Message buffering strategy between reconnection (default: FIFO buffer)
+        };
+    });
 
     request(endpoint: "info" | "action" | "explorer", payload: unknown, signal?: AbortSignal): Promise<unknown>;
     subscribe(
@@ -343,28 +447,135 @@ class WebSocketTransport implements IRESTTransport, ISubscriptionTransport {
     ready(signal?: AbortSignal): Promise<void>;
     close(signal?: AbortSignal): Promise<void>;
 }
+```
+
+## Additional Import Points
+
+The SDK exports additional import points to access internal functions.
+
+### `/types`
+
+The import point gives access to all Hyperliquid-related types, including the base types on which class methods are
+based.
+
+Useful if you want to get all Hyperliquid types.
+
+### `/signing`
+
+The import point gives access to functions that generate signatures for Hyperliquid transactions.
+
+Useful if you want to sign a Hyperliquid transaction yourself.
+
+### Examples
+
+#### Cancel an order without a client
+
+```typescript
+import { signL1Action } from "@nktkas/hyperliquid/signing";
+import type { CancelRequest, CancelResponse } from "@nktkas/hyperliquid/types";
+import { privateKeyToAccount } from "viem/accounts";
+
+// —————————— Prepare ——————————
+
+const wallet = privateKeyToAccount("0x..."); // Change to your private key
+
+// The CancelRequest["action"] type ensures that we collect the correct cancel request action
+const action: CancelRequest["action"] = { type: "cancel", cancels: [{ a: 0, o: 12345 }] };
+const nonce = Date.now();
+
+// —————————— Signing ——————————
+
+const signature = await signL1Action({
+    wallet,
+    action: sortedAction,
+    nonce,
+    isTestnet: true,
+});
+
+// —————————— Request ——————————
+
+// The CancelRequest type guarantees us that the object we want to send is valid in terms of types
+const request: CancelRequest = { action, signature, nonce };
+
+const response = await fetch("https://api.hyperliquid-testnet.xyz/exchange", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(request),
+});
+
+if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`Failed to cancel order: ${response.statusText} ${body}`);
+}
+
+// If we sent a cancel request and received a successful response, then we got exactly the CancelResponse type
+const body = await response.json() as CancelResponse;
+console.log("Order cancel response:", body);
+```
 
-interface WebSocketTransportOptions {
-    url?: string | URL; // WebSocket URL (default: "wss://api.hyperliquid.xyz/ws")
-    timeout?: number; // Request timeout in ms (default: 10_000)
-    keepAlive?: { // Keep-alive configuration
-        interval?: number; // Ping interval in ms (default: 20_000)
-    };
-    reconnect?: { // Reconnection policy configuration for closed connections
-        maxRetries?: number; // Maximum number of reconnection attempts (default: 3)
-        connectionTimeout?: number; // Connection timeout in ms (default: 10_000)
-        connectionDelay?: number | ((attempt: number) => number | Promise<number>); // Delay between reconnection (default: Exponential backoff (max 10s))
-        shouldReconnect?: (event: CloseEvent) => boolean | Promise<boolean>; // Custom reconnection logic (default: Always reconnect)
-        messageBuffer?: MessageBufferStrategy; // Message buffering strategy between reconnection (default: FIFO buffer)
-        WebSocketConstructor?: typeof WebSocket; // Custom WebSocket constructor (default: globalThis.WebSocket)
-    };
+#### Approve an agent without a client
+
+```typescript
+import { signUserSignedAction } from "@nktkas/hyperliquid/signing";
+import type { ApproveAgentRequest, ErrorResponse, SuccessResponse } from "@nktkas/hyperliquid/types";
+import { privateKeyToAccount } from "viem/accounts";
+
+// —————————— Prepare ——————————
+
+const wallet = privateKeyToAccount("0x..."); // Change to your private key
+
+// The ApproveAgentRequest["action"] type ensures that we collect the correct approve agent request action
+const action: ApproveAgentRequest["action"] = {
+    type: "approveAgent",
+    hyperliquidChain: "Testnet",
+    signatureChainId: "0x66eee",
+    nonce: Date.now(),
+    agentAddress: "0x...", // Change to the agent address you want to approve
+    agentName: "TempAgent",
+};
+
+// —————————— Signing ——————————
+
+const signature = await signUserSignedAction({
+    wallet,
+    action,
+    types: {
+        "HyperliquidTransaction:ApproveAgent": [
+            { name: "hyperliquidChain", type: "string" },
+            { name: "agentAddress", type: "address" },
+            { name: "agentName", type: "string" },
+            { name: "nonce", type: "uint64" },
+        ],
+    },
+    chainId: parseInt(action.signatureChainId, 16),
+});
+
+// —————————— Request ——————————
+
+// The ApproveAgentRequest type guarantees us that the object we want to send is valid in terms of types
+const request: ApproveAgentRequest = { action, signature, nonce: action.nonce };
+
+const response = await fetch("https://api.hyperliquid-testnet.xyz/exchange", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(request),
+});
+
+if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`Failed to approve agent: ${response.statusText} ${body}`);
 }
+
+// If we sent a request for agent approval and received a successful response,
+// we will get either a SuccessResponse type or an ErrorResponse type
+const body = await response.json() as SuccessResponse | ErrorResponse;
+console.log("Agent approval response:", body);
 ```
 
-## Semantic Versioning
+## Versioning Policy
 
-This library follows [Semantic Versioning](https://semver.org/) (or rather
-[this proposal](https://github.com/semver/semver/pull/923)) for its releases.
+This library follows a [stricter version](https://github.com/semver/semver/pull/923) of
+[Semantic Versioning](https://semver.org/) for its releases.
 
 > [!IMPORTANT]
 > To avoid rapid increase in the main version of the SDK due to changes in Hyperliquid API types, such changes are

package/esm/mod.d.ts

@@ -1,25 +1,16 @@
+export * from "./src/base.js";
+export type { AbstractEthersSigner, AbstractEthersV5Signer, AbstractExtendedViemWalletClient, AbstractViemWalletClient, AbstractWindowEthereum, } from "./src/signing.js";
 export * from "./src/clients/event.js";
 export * from "./src/clients/public.js";
 export * from "./src/clients/wallet.js";
-export * from "./src/transports/base.js";
 export * from "./src/transports/http/http_transport.js";
 export * from "./src/transports/websocket/websocket_transport.js";
-export type { MessageBufferStrategy, ReconnectingWebSocketOptions, } from "./src/transports/websocket/reconnecting_websocket.js";
-export { WebSocketRequestError } from "./src/transports/websocket/websocket_request_dispatcher.js";
-export type * from "./src/types/common.js";
-export type * from "./src/types/exchange/common.js";
-export type * from "./src/types/exchange/requests.js";
 export type * from "./src/types/exchange/responses.js";
-export type * from "./src/types/explorer/common.js";
-export type * from "./src/types/explorer/requests.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/delegations.js";
 export type * from "./src/types/info/orders.js";
-export type * from "./src/types/info/requests.js";
 export type * from "./src/types/info/vaults.js";
-export type * from "./src/types/subscriptions/common.js";
-export type * from "./src/types/subscriptions/requests.js";
-export type { AbstractEthersSigner, AbstractEthersV5Signer, AbstractViemWalletClient } from "./src/utils/signing.js";
+export type * from "./src/types/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,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AAGxC,cAAc,0BAA0B,CAAC;AAEzC,cAAc,yCAAyC,CAAC;AAExD,cAAc,mDAAmD,CAAC;AAClE,YAAY,EACR,qBAAqB,EACrB,4BAA4B,GAC/B,MAAM,sDAAsD,CAAC;AAC9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,4DAA4D,CAAC;AAGnG,mBAAmB,uBAAuB,CAAC;AAE3C,mBAAmB,gCAAgC,CAAC;AACpD,mBAAmB,kCAAkC,CAAC;AACtD,mBAAmB,mCAAmC,CAAC;AAEvD,mBAAmB,gCAAgC,CAAC;AACpD,mBAAmB,kCAAkC,CAAC;AACtD,mBAAmB,mCAAmC,CAAC;AAEvD,mBAAmB,8BAA8B,CAAC;AAClD,mBAAmB,4BAA4B,CAAC;AAChD,mBAAmB,iCAAiC,CAAC;AACrD,mBAAmB,4BAA4B,CAAC;AAChD,mBAAmB,8BAA8B,CAAC;AAClD,mBAAmB,4BAA4B,CAAC;AAEhD,mBAAmB,qCAAqC,CAAC;AACzD,mBAAmB,uCAAuC,CAAC;AAG3D,YAAY,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC"}
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AACA,cAAc,eAAe,CAAC;AAG9B,YAAY,EACR,oBAAoB,EACpB,sBAAsB,EACtB,gCAAgC,EAChC,wBAAwB,EACxB,sBAAsB,GACzB,MAAM,kBAAkB,CAAC;AAG1B,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AAGxC,cAAc,yCAAyC,CAAC;AACxD,cAAc,mDAAmD,CAAC;AAGlE,mBAAmB,mCAAmC,CAAC;AACvD,mBAAmB,mCAAmC,CAAC;AACvD,mBAAmB,8BAA8B,CAAC;AAClD,mBAAmB,4BAA4B,CAAC;AAChD,mBAAmB,iCAAiC,CAAC;AACrD,mBAAmB,4BAA4B,CAAC;AAChD,mBAAmB,4BAA4B,CAAC;AAChD,mBAAmB,wCAAwC,CAAC"}

package/esm/mod.js

@@ -1,9 +1,9 @@
+// Base interfaces
+export * from "./src/base.js";
 // Clients
 export * from "./src/clients/event.js";
 export * from "./src/clients/public.js";
 export * from "./src/clients/wallet.js";
 // Transports
-export * from "./src/transports/base.js";
 export * from "./src/transports/http/http_transport.js";
 export * from "./src/transports/websocket/websocket_transport.js";
-export { WebSocketRequestError } from "./src/transports/websocket/websocket_request_dispatcher.js";

package/esm/src/{transports/base.d.ts → base.d.ts}

@@ -1,3 +1,5 @@
+/** Hexadecimal string starting with `0x`. */
+export type Hex = `0x${string}`;
 /**
  * Interface representing a REST transport.
  * Handles communication with Hyperliquid API endpoints.
@@ -31,9 +33,7 @@ export interface ISubscriptionTransport {
      */
     subscribe(channel: string, payload: unknown, listener: (data: CustomEvent) => void, signal?: AbortSignal): Promise<Subscription>;
 }
-/**
- * Controls event subscription lifecycle.
- */
+/** Controls event subscription lifecycle. */
 export interface Subscription {
     /**
      * Unsubscribes from the event and sends an unsubscribe request to the server.
@@ -41,15 +41,12 @@ export interface Subscription {
      */
     unsubscribe(signal?: AbortSignal): Promise<void>;
 }
-/**
- * Base class for all transport-related errors.
- */
-export declare class TransportError extends Error {
-    /**
-     * Creates a new transport error.
-     * @param message - The error message.
-     * @param options - Additional error options.
-     */
-    constructor(message?: string, options?: ErrorOptions);
+/** Base class for all Hyperliquid SDK errors. */
+export declare class HyperliquidError extends Error {
+    constructor(message?: string);
+}
+/** Base class for all transport-related errors. */
+export declare class TransportError extends HyperliquidError {
+    constructor(message?: string);
 }
 //# sourceMappingURL=base.d.ts.map

package/esm/src/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/src/base.ts"],"names":[],"mappings":"AAAA,6CAA6C;AAC7C,MAAM,MAAM,GAAG,GAAG,KAAK,MAAM,EAAE,CAAC;AAEhC;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAC9B;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC/G;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACnC;;;;;;;OAOG;IACH,SAAS,CACL,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,EACrC,MAAM,CAAC,EAAE,WAAW,GACrB,OAAO,CAAC,YAAY,CAAC,CAAC;CAC5B;AAED,6CAA6C;AAC7C,MAAM,WAAW,YAAY;IACzB;;;OAGG;IACH,WAAW,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACpD;AAED,iDAAiD;AACjD,qBAAa,gBAAiB,SAAQ,KAAK;gBAC3B,OAAO,CAAC,EAAE,MAAM;CAI/B;AAED,mDAAmD;AACnD,qBAAa,cAAe,SAAQ,gBAAgB;gBACpC,OAAO,CAAC,EAAE,MAAM;CAI/B"}

package/esm/src/base.js

@@ -0,0 +1,14 @@
+/** Base class for all Hyperliquid SDK errors. */
+export class HyperliquidError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "HyperliquidError";
+    }
+}
+/** Base class for all transport-related errors. */
+export class TransportError extends HyperliquidError {
+    constructor(message) {
+        super(message);
+        this.name = "TransportError";
+    }
+}