@nktkas/hyperliquid 0.13.1 → 0.14.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2024-2025 nktkas
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+MIT License
+
+Copyright (c) 2024-2025 nktkas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.

package/README.md

@@ -1,7 +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)
+[![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.
@@ -9,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.
 
@@ -22,16 +24,16 @@ runtimes, written in TypeScript and provided with tests.
 
 ```bash
 # npm
-npx jsr add @nktkas/hyperliquid
+npm i @nktkas/hyperliquid
 
 # yarn 
-yarn dlx jsr add @nktkas/hyperliquid
+yarn add @nktkas/hyperliquid
 
 # pnpm
-pnpm dlx jsr add @nktkas/hyperliquid
+pnpm add @nktkas/hyperliquid
 
 # bun
-bunx jsr add @nktkas/hyperliquid
+bun i @nktkas/hyperliquid
 
 # deno
 deno add jsr:@nktkas/hyperliquid
@@ -50,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
 
@@ -80,7 +76,6 @@ const client = new hl.PublicClient({ transport });
 ```typescript
 import * as hl from "@nktkas/hyperliquid";
 import { createWalletClient, custom } from "viem";
-import { arbitrum } from "viem/chains";
 import { privateKeyToAccount } from "viem/accounts";
 import { ethers } from "ethers";
 
@@ -96,12 +91,11 @@ 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,
-    chain: arbitrum,
-    transport: custom(window.ethereum),
-});
-const metamaskClient = new hl.WalletClient({ wallet: externalWallet, transport });
+const externalWallet = createWalletClient({ account, transport: custom(window.ethereum) });
+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
@@ -109,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
@@ -130,20 +215,19 @@ 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>;
     spotMeta(): Promise<SpotMeta>;
@@ -151,35 +235,47 @@ 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[]>;
+    delegatorHistory(args: DelegatorHistoryParameters): Promise<DelegatorUpdate[]>;
+    delegatorRewards(args: DelegatorRewardsParameters): Promise<DelegatorReward[]>;
+    delegatorSummary(args: DelegatorSummaryParameters): Promise<DelegatorSummary>;
+    validatorSummaries(): Promise<ValidatorSummary[]>;
 
     // Vault
-    userVaultEquities(args: UserVaultEquitiesParameters): Promise<UserVaultEquity[]>;
+    userVaultEquities(args: UserVaultEquitiesParameters): Promise<VaultEquity[]>;
     vaultDetails(args: VaultDetailsParameters): Promise<VaultDetails | null>;
     vaultSummaries(): Promise<VaultSummary[]>;
 
-    // Blockchain
+    // Explorer
     blockDetails(args: BlockDetailsParameters): Promise<BlockDetailsResponse>;
     txDetails(args: TxDetailsParameters): Promise<TxDetailsResponse>;
+    userDetails(args: UserDetailsParameters): Promise<UserDetailsResponse>;
 }
 ```
 
@@ -194,23 +290,20 @@ 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 Management
+    // Order
     batchModify(args: BatchModifyParameters): Promise<OrderResponseSuccess>;
     cancel(args: CancelParameters): Promise<CancelResponseSuccess>;
     cancelByCloid(args: CancelByCloidParameters): Promise<CancelResponseSuccess>;
@@ -222,19 +315,33 @@ class WalletClient<
     updateIsolatedMargin(args: UpdateIsolatedMarginParameters): Promise<SuccessResponse>;
     updateLeverage(args: UpdateLeverageParameters): Promise<SuccessResponse>;
 
-    // Account Management
+    // 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>;
 }
 ```
 
@@ -248,14 +355,12 @@ 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 {
+    constructor(args: {
+        transport: WebSocketTransport;
+    });
 
-class EventClient<T extends ISubscriptionTransport> {
-    constructor(args: EventClientParameters<T>);
-
-    // Market Data
+    // Market
     activeAssetCtx(args: EventActiveAssetCtxParameters, listener: (data: WsActiveAssetCtx | WsActiveSpotAssetCtx) => void): Promise<Subscription>;
     activeAssetData(args: EventActiveAssetDataParameters, listener: (data: WsActiveAssetData) => void): Promise<Subscription>;
     allMids(listener: (data: WsAllMids) => void): Promise<Subscription>;
@@ -263,18 +368,22 @@ class EventClient<T extends ISubscriptionTransport> {
     l2Book(args: EventL2BookParameters, listener: (data: Book) => void): Promise<Subscription>;
     trades(args: EventTradesParameters, listener: (data: WsTrade[]) => void): Promise<Subscription>;
 
-    // Account/User Data
+    // Account
     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>;
 
-    // Order Management
-    orderUpdates(args: EventOrderUpdatesParameters, listener: (data: OrderStatus) => 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>;
+
+    // Explorer
+    explorerBlock(listener: (data: WsBlockDetails[]) => void): Promise<Subscription>;
+    explorerTx(listener: (data: TxDetails[]) => void): Promise<Subscription>;
 }
 ```
 <!-- deno-fmt-ignore-end -->
@@ -292,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
@@ -313,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(
@@ -327,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}`);
+}
 
-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)
-    };
+// 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);
+```
+
+#### 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/deps/jsr.io/@std/bytes/1.0.5/_types.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Proxy type of {@code Uint8Array<ArrayBuffer} or {@code Uint8Array} in TypeScript 5.7 or below respectively.
+ *
+ * This type is internal utility type and should not be used directly.
+ *
+ * @internal @private
+ */
+export type Uint8Array_ = ReturnType<Uint8Array["slice"]>;
+//# sourceMappingURL=_types.d.ts.map