├── .env.example
├── .github
    └── workflows
    │   └── npm-publish.yml
├── .gitignore
├── .prettierignore
├── .prettierrc.js
├── BROWSER.md
├── README.md
├── bug_report_template.md
├── changelog.txt
├── deno.json
├── examples
    ├── browser-test.html
    ├── exchange_api_testing.cjs
    ├── info_api_testing.cjs
    └── ws_test.cjs
├── mod.ts
├── package-lock.json
├── package.json
├── pnpm-lock.yaml
├── src
    ├── browser.ts
    ├── global.d.ts
    ├── index.ts
    ├── rest
    │   ├── custom.ts
    │   ├── exchange.ts
    │   ├── info.ts
    │   └── info
    │   │   ├── general.ts
    │   │   ├── perpetuals.ts
    │   │   └── spot.ts
    ├── types
    │   ├── constants.ts
    │   └── index.ts
    ├── utils
    │   ├── environment.ts
    │   ├── errors.ts
    │   ├── helpers.ts
    │   ├── rateLimiter.ts
    │   ├── signing.ts
    │   └── symbolConversion.ts
    └── websocket
    │   ├── connection.ts
    │   └── subscriptions.ts
├── tests
    └── test1.js
├── tsconfig.json
├── tsup.config.ts
└── update_instructions.txt


/.env.example:
--------------------------------------------------------------------------------
1 | private_key=private_key
2 | user_address=xxx
3 | cloid=cloid


--------------------------------------------------------------------------------
/.github/workflows/npm-publish.yml:
--------------------------------------------------------------------------------
 1 | name: Publish Package to NPM
 2 | on:
 3 |   push:
 4 |     tags:
 5 |       - 'v*'
 6 | 
 7 | jobs:
 8 |   build:
 9 |     runs-on: ubuntu-latest
10 |     steps:
11 |       - uses: actions/checkout@v3
12 |       - uses: actions/setup-node@v3
13 |         with:
14 |           node-version: '18.x'
15 |           registry-url: 'https://registry.npmjs.org'
16 |       - run: npm ci
17 |       - run: npm run build
18 |       - run: npm publish
19 |         env:
20 |           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
21 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # Dependency directories
2 | node_modules/
3 | *.js.map
4 | src/**/*.js
5 | **/venv/** */
6 | .env
7 | .vscode/
8 | /dist
9 | *.env


--------------------------------------------------------------------------------
/.prettierignore:
--------------------------------------------------------------------------------
 1 | # Build outputs
 2 | dist/
 3 | build/
 4 | coverage/
 5 | 
 6 | # Package files
 7 | node_modules/
 8 | package-lock.json
 9 | pnpm-lock.yaml
10 | yarn.lock
11 | 
12 | # Generated files
13 | *.min.js
14 | *.bundle.js
15 | 
16 | # Specific directories
17 | .github/
18 | .vscode/
19 | 
20 | # Misc
21 | .DS_Store
22 | .env
23 | .env.*
24 | 


--------------------------------------------------------------------------------
/.prettierrc.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 |   printWidth: 100,
 3 |   tabWidth: 2,
 4 |   useTabs: false,
 5 |   semi: true,
 6 |   singleQuote: true,
 7 |   quoteProps: 'as-needed',
 8 |   jsxSingleQuote: false,
 9 |   trailingComma: 'es5',
10 |   bracketSpacing: true,
11 |   bracketSameLine: false,
12 |   arrowParens: 'avoid',
13 |   endOfLine: 'lf',
14 |   overrides: [
15 |     {
16 |       files: '*.ts',
17 |       options: {
18 |         parser: 'typescript',
19 |       },
20 |     },
21 |   ],
22 | };
23 | 


--------------------------------------------------------------------------------
/BROWSER.md:
--------------------------------------------------------------------------------
  1 | # Browser Usage Guide
  2 | 
  3 | The Hyperliquid SDK supports browser environments and can be used in several ways:
  4 | 
  5 | ## Direct Script Include
  6 | 
  7 | ```html
  8 | <script src="https://unpkg.com/hyperliquid/dist/browser.global.js"></script>
  9 | <script>
 10 |     const sdk = new HyperliquidSDK.Hyperliquid({
 11 |         testnet: true,
 12 |         enableWs: true
 13 |     });
 14 | </script>
 15 | ```
 16 | 
 17 | ## ES Module Import
 18 | 
 19 | ```javascript
 20 | import { Hyperliquid } from 'hyperliquid';
 21 | 
 22 | const sdk = new Hyperliquid({
 23 |     testnet: true,
 24 |     enableWs: true
 25 | });
 26 | ```
 27 | 
 28 | Note: See /examples/browser-test.html for a complete example of how to use the SDK in a browser with all methods supported. P.s. Try running it in a local server to just test the SDK/API in general
 29 | 
 30 | ## Features and Limitations
 31 | 
 32 | ### Supported Features
 33 | - REST API calls
 34 | - WebSocket real-time updates
 35 | - Wallet integration via ethers.js
 36 | - Asset conversion and management
 37 | - Real-time market data subscriptions
 38 | 
 39 | ### Browser-Specific Considerations
 40 | 
 41 | 1. **WebSocket Support**
 42 |    - WebSocket functionality is automatically enabled in supported browsers
 43 |    - Falls back gracefully if WebSocket is not supported
 44 | 
 45 | 2. **Private Key Handling**
 46 |    - Never store private keys in browser storage
 47 |    - Consider using Web3 wallet providers for key management
 48 |    - Use environment variables for server-side private keys
 49 | 
 50 | 3. **CORS**
 51 |    - All API endpoints support CORS
 52 |    - No additional configuration needed for browser usage
 53 | 
 54 | 4. **Performance**
 55 |    - Rate limiting is handled automatically
 56 |    - WebSocket connections are managed with automatic reconnection
 57 |    - Memory usage is optimized for browser environments
 58 | 
 59 | ## Example Usage
 60 | 
 61 | ```javascript
 62 | async function init() {
 63 |     const sdk = new Hyperliquid({
 64 |         testnet: true,
 65 |         enableWs: true
 66 |     });
 67 | 
 68 |     // Connect to the API
 69 |     await sdk.connect();
 70 | 
 71 |     // Get market data
 72 |     const assets = await sdk.info.getAllAssets();
 73 |     console.log('Available assets:', assets);
 74 | 
 75 |     // Subscribe to real-time updates
 76 |     sdk.subscriptions.subscribeToAllMids((data) => {
 77 |         console.log('Price update:', data);
 78 |     });
 79 | 
 80 |     // Clean up when done
 81 |     // sdk.disconnect();
 82 | }
 83 | ```
 84 | 
 85 | ## Error Handling
 86 | 
 87 | ```javascript
 88 | try {
 89 |     await sdk.connect();
 90 | } catch (error) {
 91 |     if (error.message.includes('WebSocket')) {
 92 |         console.error('WebSocket connection failed:', error);
 93 |     } else if (error.message.includes('network')) {
 94 |         console.error('Network error:', error);
 95 |     } else {
 96 |         console.error('Unknown error:', error);
 97 |     }
 98 | }
 99 | ```
100 | 
101 | ## Best Practices
102 | 
103 | 1. Always call `connect()` before using the SDK
104 | 2. Handle WebSocket reconnection events
105 | 3. Implement proper error handling
106 | 4. Clean up resources using `disconnect()` when done
107 | 5. Don't store sensitive data in browser storage
108 | 6. Use appropriate security measures for private keys 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Hyperliquid API SDK
  2 | 
  3 | Typescript SDK to more easily interact with Hyperliquid's API
  4 | 
  5 | All info on the Hyperliquid API can be found here: [HyperLiquid API Documentation](https://hyperliquid.gitbook.io/hyperliquid-docs)
  6 | 
  7 | ## Features
  8 | 
  9 | - Complete API coverage for both REST and WebSocket endpoints
 10 | - TypeScript support with comprehensive type definitions
 11 | - Browser and Node.js compatibility
 12 | - Automatic handling of trailing zeros in price and size fields
 13 | - Rate limiting support
 14 | - Comprehensive error handling
 15 | 
 16 | ## Installation
 17 | 
 18 | Choose your preferred installation method:
 19 | 
 20 | ### Package Managers
 21 | 
 22 | ```bash
 23 | # npm
 24 | npm i --save hyperliquid
 25 | 
 26 | # yarn
 27 | yarn add hyperliquid
 28 | 
 29 | # pnpm
 30 | pnpm add hyperliquid
 31 | 
 32 | # bun
 33 | bun i hyperliquid
 34 | ```
 35 | 
 36 | ### Node.js Version Requirements for WebSocket Functionality
 37 | 
 38 | This SDK uses native WebSocket implementation which requires Node.js version 22 or higher. If you're using an earlier version of Node.js, you'll need to install the `ws` package to use the WebSocket functionality:
 39 | 
 40 | ```bash
 41 | npm install ws
 42 | ```
 43 | 
 44 | ### Direct Web Usage
 45 | 
 46 | ```html
 47 | <!-- Global bundle (UMD) - Use this with script tags -->
 48 | <script src="https://unpkg.com/hyperliquid/dist/browser.global.js"></script>
 49 | 
 50 | <!-- ESM bundle - Use this with ES modules -->
 51 | <script type="module">
 52 |   import { Hyperliquid } from "https://unpkg.com/hyperliquid/dist/browser.js";
 53 | </script>
 54 | 
 55 | ```
 56 | 
 57 | The SDK provides two browser bundles:
 58 | - `browser.global.js`: UMD bundle that exposes the SDK globally as `HyperliquidSDK`. Use this with regular `<script>` tags.
 59 | - `browser.js`: ESM bundle for use with ES modules (import/export syntax).
 60 | 
 61 | For Browser usage, see [Browser Usage Guide](/BROWSER.md).
 62 | 
 63 | ## Usage
 64 | 
 65 | **API Agent Wallet Usage:** If you are using API Agent wallets everything works as normal but you need to add your actual account's wallet address in the Hyperliquid object field 'walletAddress'.
 66 | 
 67 | If you don't do this you will be unable to use some of the SDK methods successfully. If you are using
 68 | your own Private Key then it's not necessary as the SDK can derive your wallet address from the Private key.
 69 | ```typescript
 70 | const { Hyperliquid } = require('hyperliquid');
 71 | 
 72 | const sdk = new Hyperliquid({
 73 |   enableWs: true, // boolean (OPTIONAL) - Enable/disable WebSocket functionality, defaults to true
 74 |   privateKey: <private_key - string>,
 75 |   testnet: <testnet - boolean (OPTIONAL)>,
 76 |   walletAddress: <walletAddress - string (Required if you are using an API Agent Wallet, otherwise not necessary)>,
 77 |   vaultAddress: <vaultAddress - string (OPTIONAL)>,
 78 |   maxReconnectAttempts: <number (OPTIONAL)> // Default is 5, controls WebSocket reconnection attempts
 79 | });
 80 | 
 81 | // Use the SDK methods
 82 | sdk.info.getAllMids().then(allMids => {
 83 |   console.log(allMids);
 84 | });
 85 | ```
 86 | **Note:** You don't have to provide your private key, but it is required if you want to
 87 | use the exchange API to place, cancel or modify orders or access your accounts assets.
 88 | WebSocket functionality is enabled by default but can be disabled by setting `enableWs: false` in the constructor options.
 89 | 
 90 | ## Key Features
 91 | 
 92 | ### Rate Limiting
 93 | 
 94 | The SDK implements Hyperliquid's token bucket rate limiting system:
 95 | - 100 tokens maximum capacity
 96 | - 10 tokens per second refill rate
 97 | - Automatic handling of rate limits with proper backoff
 98 | 
 99 | The SDK will automatically wait when rate limits are reached, ensuring your API calls succeed without overwhelming the server.
100 | 
101 | ### WebSocket Management
102 | 
103 | The SDK provides robust WebSocket connection handling:
104 | - Automatic reconnection with exponential backoff
105 | - Ping/pong heartbeat mechanism to detect stale connections
106 | - Subscription limit tracking (maximum 1000 subscriptions per IP)
107 | - Proper cleanup of subscriptions when no longer needed
108 | 
109 | ### Secure Nonce Generation
110 | 
111 | For authenticated requests, the SDK uses a secure nonce generation system:
112 | - Monotonically increasing timestamps
113 | - Handles multiple requests in the same millisecond
114 | - Ensures compliance with Hyperliquid's nonce requirements
115 | 
116 | ## Symbol Naming Convention
117 | 
118 | Instead of using native symbols (which can be confusing, like @1, @4, @5 for spot and only the coin name for perps), we've implemented a more intuitive naming system:
119 | 
120 | - For perpetuals: `<coin>-PERP` (e.g., BTC-PERP, ETH-PERP)
121 | - For spot: `<coin>-SPOT` (e.g., PURR-SPOT, BTC-SPOT)
122 | 
123 | This convention makes it easier to distinguish between spot and perpetual markets.
124 | 
125 | ## Examples
126 | 
127 | ### Exchange API Methods
128 | 
129 | ```typescript
130 | // Place an order
131 | sdk.exchange.placeOrder({
132 |   coin: 'BTC-PERP',
133 |   is_buy: true,
134 |   sz: 1,
135 |   limit_px: 30000,
136 |   order_type: { limit: { tif: 'Gtc' } },
137 |   reduce_only: false,
138 |   vaultAddress: '0x...' // optional
139 | }).then(placeOrderResult => {
140 |   console.log(placeOrderResult);
141 | }).catch(error => {
142 |   console.error('Error placing order:', error);
143 | });
144 | 
145 | // Reserve additional actions for rate limits
146 | // This costs 0.0005 USDC per request instead of trading to increase rate limits
147 | sdk.exchange.reserveRequestWeight(1).then(result => {
148 |   console.log('Reserved additional actions:', result);
149 | }).catch(error => {
150 |   console.error('Error reserving actions:', error);
151 | });
152 | 
153 | // Multiple orders can be passed as an array or order objects
154 | // The grouping, vaultAddress and builder properties are optional
155 | // Grouping determines how multiple orders are treated by the exchange endpoint in terms
156 | // of transaction priority, execution and dependency. Defaults to 'na' if not specified.
157 | sdk.exchange.placeOrder({
158 |   orders: [{
159 |     coin: 'BTC-PERP',
160 |     is_buy: true,
161 |     sz: 1,
162 |     limit_px: 30000,
163 |     order_type: { limit: { tif: 'Gtc' } },
164 |     reduce_only: false
165 |   }],
166 |   vaultAddress: '0x...',
167 |   grouping: 'normalTpsl',
168 |   builder: {
169 |     address: '0x...',
170 |     fee: 999,
171 |   }
172 | }).then(placeOrderResult => {
173 |   console.log(placeOrderResult);
174 | }).catch(error => {
175 |   console.error('Error placing order:', error);
176 | });
177 | 
178 | // Cancel an order
179 | sdk.exchange.cancelOrder({
180 |   coin: 'BTC-PERP',
181 |   o: 123456 // order ID
182 | }).then(cancelOrderResult => {
183 |   console.log(cancelOrderResult);
184 | }).catch(error => {
185 |   console.error('Error cancelling order:', error);
186 | });
187 | 
188 | // Transfer between perpetual and spot accounts
189 | sdk.exchange.transferBetweenSpotAndPerp(100, true) // Transfer 100 USDC from spot to perp
190 |   .then(transferResult => {
191 |     console.log(transferResult);
192 |   }).catch(error => {
193 |     console.error('Error transferring funds:', error);
194 |   });
195 | ```
196 | All methods supported can be found here: [Hyperliquid Exchange Endpoint API Documentation](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint)
197 | 
198 | ### General Info Methods
199 | 
200 | ```typescript
201 | // Get all mids
202 | sdk.info.getAllMids().then(allMids => {
203 |   console.log(allMids);
204 | }).catch(error => {
205 |   console.error('Error getting all mids:', error);
206 | });
207 | 
208 | // Get user open orders
209 | sdk.info.getUserOpenOrders('user_address_here').then(userOpenOrders => {
210 |   console.log(userOpenOrders);
211 | }).catch(error => {
212 |   console.error('Error getting user open orders:', error);
213 | });
214 | 
215 | // Get L2 order book
216 | sdk.info.getL2Book('BTC-PERP').then(l2Book => {
217 |   console.log(l2Book);
218 | }).catch(error => {
219 |   console.error('Error getting L2 book:', error);
220 | });
221 | ```
222 | 
223 | All methods supported can be found here: [Hyperliquid Info Endpoint API Documentation](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint)
224 | 
225 | ### WebSocket Methods
226 | 
227 | #### WebSocket Subscriptions
228 | 
229 | ```typescript
230 | const { Hyperliquid } = require('hyperliquid');
231 | 
232 | async function testWebSocketSubscriptions() {
233 |     // Create a new Hyperliquid instance
234 |     // You can pass a privateKey in the options if you need authenticated access
235 |     const sdk = new Hyperliquid({ enableWs: true });
236 | 
237 |     try {
238 |         // Connect to the WebSocket
239 |         await sdk.connect();
240 |         console.log('Connected to WebSocket');
241 | 
242 |         // Subscribe to get latest prices for all coins
243 |         sdk.subscriptions.subscribeToAllMids((data) => {
244 |             console.log('Received trades data:', data);
245 |         });
246 | 
247 |         // Get updates anytime the user gets new fills
248 |         sdk.subscriptions.subscribeToUserFills("<wallet_address_here>", (data) => {
249 |             console.log('Received user fills data:', data);
250 |         });
251 | 
252 |         // Get updates on 1 minute ETH-PERP candles
253 |         sdk.subscriptions.subscribeToCandle("BTC-PERP", "1m", (data) => {
254 |             console.log('Received candle data:', data);
255 |         });
256 | 
257 |         // Keep the script running
258 |         await new Promise(() => {});
259 |     } catch (error) {
260 |         console.error('Error:', error);
261 |     }
262 | }
263 | 
264 | testWebSocketSubscriptions();
265 | ```
266 | 
267 | #### WebSocket POST Requests
268 | 
269 | You can also use WebSocket to send POST requests instead of using HTTP. This is useful for high-frequency trading or when you need to minimize latency.
270 | 
271 | ```typescript
272 | const { Hyperliquid } = require('hyperliquid');
273 | 
274 | async function testWebSocketPostRequests() {
275 |     // Create a new Hyperliquid instance
276 |     const sdk = new Hyperliquid({
277 |         enableWs: true,
278 |         // Include privateKey for authorized requests
279 |         privateKey: 'your_private_key' // Optional, only needed for authorized requests
280 |     });
281 | 
282 |     try {
283 |         // Connect to the WebSocket
284 |         await sdk.connect();
285 |         console.log('Connected to WebSocket');
286 | 
287 |         // Wait a moment to ensure connection is fully established
288 |         await new Promise(resolve => setTimeout(resolve, 1000));
289 | 
290 |         // Example 1: Unauthorized POST request (info endpoint)
291 |         const l2BookResponse = await sdk.subscriptions.postRequest('info', {
292 |             type: 'l2Book',
293 |             coin: 'BTC'
294 |         });
295 |         console.log('L2 Book Response:', l2BookResponse);
296 | 
297 |         // Example 2: Authorized POST request (exchange endpoint)
298 |         // Only works if privateKey is provided
299 |         if (sdk.isAuthenticated()) {
300 |             // Generate order payload
301 |             const orderPayload = await sdk.exchange.getOrderPayload({
302 |                 coin: 'BTC',
303 |                 is_buy: true,
304 |                 sz: '0.001',
305 |                 limit_px: '50000', // Far from market price for safety
306 |                 order_type: { limit: { tif: 'Gtc' } },
307 |                 reduce_only: false
308 |             });
309 | 
310 |             // Send the order via WebSocket
311 |             const orderResponse = await sdk.subscriptions.postRequest('action', orderPayload);
312 |             console.log('Place Order Response:', orderResponse);
313 | 
314 |             // Cancel all orders
315 |             const cancelAllPayload = await sdk.exchange.getCancelAllPayload();
316 |             const cancelAllResponse = await sdk.subscriptions.postRequest('action', cancelAllPayload);
317 |             console.log('Cancel All Orders Response:', cancelAllResponse);
318 |         }
319 |     } catch (error) {
320 |         console.error('Error:', error);
321 |     } finally {
322 |         // Disconnect WebSocket when done
323 |         sdk.disconnect();
324 |     }
325 | }
326 | 
327 | testWebSocketPostRequests();
328 | ```
329 | 
330 | **Notes:**
331 | - The WebSocket connection must be fully established before sending POST requests. It's recommended to add a short delay after connecting before sending the first request.
332 | - For authorized requests, the SDK will use the wallet address as the vault address if no vault address is explicitly provided. If you're using a specific vault, make sure to provide the vault address when initializing the SDK.
333 | 
334 | ## Automatic Handling of Trailing Zeros
335 | 
336 | The Hyperliquid API requires that price (`p`) and size (`s`) fields do not contain trailing zeros. For example:
337 | - `12345.0` should be `12345`
338 | - `0.123450` should be `0.12345`
339 | 
340 | This SDK automatically handles this requirement for you in all relevant methods. When you use methods like `placeOrder`, `modifyOrder`, or `batchModifyOrders`, the SDK will automatically remove trailing zeros from price and size values.
341 | 
342 | You can also use string values for price and size fields, which will be properly formatted:
343 | 
344 | ```typescript
345 | // Both of these will work correctly
346 | await sdk.exchange.placeOrder({
347 |   coin: "BTC-PERP",
348 |   is_buy: true,
349 |   sz: "1.0000",  // Will be automatically converted to "1"
350 |   limit_px: "50000.00",  // Will be automatically converted to "50000"
351 |   reduce_only: false,
352 |   order_type: { limit: { tif: 'Gtc' } }
353 | });
354 | 
355 | await sdk.exchange.placeOrder({
356 |   coin: "BTC-PERP",
357 |   is_buy: true,
358 |   sz: 1,  // Numeric values also work
359 |   limit_px: 50000,
360 |   reduce_only: false,
361 |   order_type: { limit: { tif: 'Gtc' } }
362 | });
363 | ```
364 | 
365 | If you're using the low-level `signL1Action` function directly, the SDK will also automatically normalize the action object to remove trailing zeros.
366 | 
367 | ### Spot Info Methods
368 | 
369 | ```typescript
370 | //Get spot metadata
371 | sdk.info.spot.getSpotMeta().then(spotMeta => {
372 |   console.log(spotMeta);
373 | }).catch(error => {
374 |   console.error('Error getting spot metadata:', error);
375 | });
376 | 
377 | // Get spot clearinghouse state
378 | sdk.info.spot.getSpotClearinghouseState('user_address_here').then(spotClearinghouseState => {
379 |   console.log(spotClearinghouseState);
380 | }).catch(error => {
381 |   console.error('Error getting spot clearinghouse state:', error);
382 | });
383 | ```
384 | All methods supported can be found here: [Hyperliquid Spot Info Endpoint API Documentation](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/spot)
385 | 
386 | ### Perpetuals Info Methods
387 | 
388 | ```typescript
389 | // Get perpetuals metadata
390 | sdk.info.perpetuals.getMeta().then(perpsMeta => {
391 |   console.log(perpsMeta);
392 | }).catch(error => {
393 |   console.error('Error getting perpetuals metadata:', error);
394 | });
395 | 
396 | // Get user's perpetuals account summary
397 | sdk.info.perpetuals.getClearinghouseState('user_address_here').then(clearinghouseState => {
398 |   console.log(clearinghouseState);
399 | }).catch(error => {
400 |   console.error('Error getting clearinghouse state:', error);
401 | });
402 | ```
403 | All methods supported can be found here: [Hyperliquid Perpetuals Info Endpoint API Documentation](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/perpetuals)
404 | 
405 | ### Custom Methods
406 | 
407 | ```typescript
408 | // Cancel all orders
409 | sdk.custom.cancelAllOrders().then(cancelAllResult => {
410 |   console.log(cancelAllResult);
411 | }).catch(error => {
412 |   console.error('Error cancelling all orders:', error);
413 | });
414 | 
415 | // Cancel all orders for a specific symbol
416 | sdk.custom.cancelAllOrders('BTC-PERP').then(cancelAllBTCResult => {
417 |   console.log(cancelAllBTCResult);
418 | }).catch(error => {
419 |   console.error('Error cancelling all BTC-PERP orders:', error);
420 | });
421 | 
422 | // Get all tradable assets
423 | const allAssets = sdk.custom.getAllAssets();
424 | console.log(allAssets);
425 | ```
426 | All Custom methods are listed above. These are custom methods that are not part of the official Hyperliquid API. As more are added we will add examples for them here.
427 | 
428 | ## WebSocket Subscription Limits
429 | 
430 | The Hyperliquid API imposes a limit of 1000 WebSocket subscriptions per IP address. The SDK automatically tracks and manages these subscriptions to prevent exceeding this limit. If you attempt to create more than 1000 subscriptions, the SDK will throw an error.
431 | 
432 | To manage your subscriptions effectively:
433 | - Unsubscribe from feeds you no longer need
434 | - Reuse existing subscriptions where possible
435 | - Monitor your subscription count with `sdk.ws.getSubscriptionCount()`
436 | 
437 | ## Initialization
438 | 
439 | In most cases the SDK will automatically initialize itself when required. However, in some cases you may need to explicitly initialize the SDK. You can use this method to initialize the SDK:
440 | 
441 | ```typescript
442 | await sdk.connect();
443 | ```
444 | 
445 | p.s. You only need to worry about this if the SDK throws you an error telling you that it needs to be initialized.
446 | 
447 | ## Star History
448 | 
449 | [![Star History Chart](https://api.star-history.com/svg?repos=nomeida/hyperliquid&type=Date)](https://star-history.com/#nomeida/hyperliquid&Date)
450 | 
451 | ## Documentation
452 | 
453 | For more detailed documentation on all available methods and their parameters, please refer to the [official Hyperliquid API documentation](https://hyperliquid.gitbook.io/hyperliquid-docs/).
454 | 
455 | ## Disclaimer
456 | If you don't have an existing referral and use this SDK then your referral will be set by the SDK. This gives you a 4% discount on fees and gives me a percentage of the fees you pay so that I can keep working on and maintaining the SDK. You get a 4% fee discount & an easy-to-use SDK and in return I get some compensation for maintaining it, win-win
457 | 
458 | *p.s. All referral commissions from this SDK will go towards buying HYPE and other HL-related coins, so it will function as an extension of the assistance fund essentially*
459 | 
460 | ## Reporting Issues
461 | 
462 | If you encounter any issues with the SDK, please use the bug report template when creating a new issue on GitHub. This helps us gather all the necessary information to diagnose and fix the problem efficiently.
463 | 
464 | To report a bug:
465 | 1. Go to the [Issues tab](https://github.com/nomeida/hyperliquid/issues)
466 | 2. Click "New Issue"
467 | 3. Select the "Bug Report" template
468 | 4. Fill in all the requested information, including:
469 |    - Description of the issue
470 |    - Steps to reproduce
471 |    - Expected behavior
472 |    - Actual behavior
473 |    - Environment details (OS, Node.js version, etc.)
474 |    - Any relevant logs or screenshots
475 | 
476 | Using the bug report template ensures we have all the necessary information to address your issue quickly and effectively.
477 | 
478 | ## License
479 | 
480 | MIT
481 | 


--------------------------------------------------------------------------------
/bug_report_template.md:
--------------------------------------------------------------------------------
 1 | # Bug Report
 2 | 
 3 | ## Description
 4 | <!-- Provide a clear, concise description of the bug -->
 5 | 
 6 | ## Package Information
 7 | - Package version: <!-- e.g., "4.17.21" -->
 8 | - Installation method (optional): <!-- npm, yarn, pnpm, etc. -->
 9 | 
10 | ## Environment
11 | - Node.js version: <!-- e.g., "16.15.1" -->
12 | - Browser (if applicable): <!-- e.g., "Chrome 103.0.5060.53" -->
13 | 
14 | ## Steps To Reproduce the bug
15 | 1. 
16 | 2. 
17 | 3. 
18 | 
19 | ## Expected Behavior
20 | <!-- What you expected to happen -->
21 | 
22 | ## Actual Behavior
23 | <!-- What actually happened -->
24 | 
25 | ## Code Sample (optional)
26 | **Note: Please provide a code example that actually works and can be copy-pasted**
27 | ```javascript
28 | // Minimal code example that reproduces the issue
29 | // Please make this as small as possible while still demonstrating the bug
30 | ```
31 | 
32 | ## Error Messages
33 | ```
34 | // If applicable, paste full error messages, stack traces, or logs here
35 | ```
36 | 
37 | 
38 | 
39 | ## Possible Solution (optional)
40 | <!-- Optional: If you have ideas on how to fix the issue -->
41 | 
42 | ## Workaround (optional)
43 | <!-- Optional: If you've found a temporary workaround -->
44 | 
45 | ## Additional Context (optional)
46 | <!-- Any other information that might be helpful, such as screenshots, related issues, etc. -->
47 | 


--------------------------------------------------------------------------------
/changelog.txt:
--------------------------------------------------------------------------------
 1 | # Version 1.7.5
 2 | 
 3 | ## Improvements:
 4 | - After auto-reconnecting to websocket we also auto-resubscribe to all the subscriptions the user previously had
 5 | 
 6 | - BBO WebSocket topic added
 7 | 
 8 | - Reserve Rate limit endpoint added
 9 | 
10 | ## Bug Fixes:
11 | - Modify Order Endpoint can be used with both CLOID and Order ID now
12 | 
13 | - Bulk order requests fixed so they work properly again
14 | 
15 | - Fixed issue with infinite refreshing of asset maps
16 | 
17 | ## For the Nerds
18 | - Added prettier for consistent code formatting/styling, check .prettierrc.js for style rules
19 | 
20 | 
21 | # Version 1.7.4
22 | 
23 | Mostly just bug fixes this time around, but sghould make for a better user experience
24 | 
25 | Bug Fixes:
26 | - `approveBuilderFee` and using builder codes for orders works now
27 | 
28 | - Multi-order placement works again (accidentally broken in last version)
29 | 
30 | - Edge case with BTC-PERP market orders fixed
31 | 
32 | - Testnet now works without problems
33 | 
34 | - Fixed a problem where a background API call would fail and create tons of error logs
35 | 
36 | 
37 | 
38 | # Version 1.7.3
39 | 
40 | ## Bug Fixes:
41 | - **WebSocket:** Fixed issue with WebSockets reconnecting automatically after a user-initiated manual disconnect
42 | 
43 | ## New API Methods: Added 12 new methods
44 | ```
45 |   - claimRewards: Claim available rewards
46 |   - createSubAccount: Create a new sub-account
47 |   - setDisplayName: Set display name for an account (leaderboard)
48 |   - spotUser: Opt in/out of spot dusting (HL removing small balances from your account each day)
49 |   - createVault: Create a new vault
50 |   - vaultDistribute: Distribute assets from a vault
51 |   - vaultModify: Modify vault parameters
52 |   - cDeposit: Deposit for staking
53 |   - cWithdraw: Withdraw staking
54 |   - tokenDelegate: Delegate tokens to validators (or undelegate)
55 |   - subAccountSpotTransfer: Transfer spot assets between sub-accounts
56 |   - subAccountTransfer: Transfer assets between sub-accounts
57 | ```
58 | 
59 | # Version 1.7.0
60 | 
61 | ## New things introduced:
62 | - **Automatic Trailing Zeros Handling:** Added automatic removal of trailing zeros for price and size fields to prevent "L1 error: User or API Wallet 0x... does not exist" errors
63 | - **Rate Limiting:** Implemented official token bucket system (100 tokens, 10/sec refill)
64 | - **WebSocket:** Added heartbeat detection, better reconnection, and subscription limit tracking (prevent 429 errors)
65 | - **Nonce Generation:** Enhanced for reliability with monotonically increasing values
66 | - **API Methods: Added 15 new methods
67 | ```
68 |   - validatorSummaries: Get summaries of all validators
69 |   - vaultSummaries: Get summaries of all vaults
70 |   - blockDetails: Get details of a specific block
71 |   - txDetails: Get details of a specific transaction
72 |   - userDetails: Get details of a specific user
73 |   - userFees: Get fee information for a user
74 |   - portfolio: Get portfolio information for a user
75 |   - preTransferCheck: Check if a transfer is possible between addresses
76 |   - referral: Get referral information for a user
77 |   - extraAgents: Get extra agent information for a user
78 |   - isVip: Check if a user has VIP status
79 |   - legalCheck: Perform legal compliance check for a user
80 |   - userTwapSliceFillsByTime: Get TWAP slice fills for a user in a time range
81 |   - twapHistory: Get TWAP history for a user
82 |   - userToMultiSigSigners: Get multi-sig signers for a user
83 | ```
84 | 
85 | 


--------------------------------------------------------------------------------
/deno.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "@nktkas/hyperliquid",
 3 |   "version": "1.5.8",
 4 |   "exports": {
 5 |     ".": "./mod.ts"
 6 |   },
 7 |   "imports": {
 8 |     "ethers": "npm:ethers@6.13.2",
 9 |     "@msgpack/msgpack": "npm:@msgpack/msgpack@3.0.0-beta2",
10 |     "axios": "npm:axios@1.7.2"
11 |   },
12 |   "publish": {
13 |     "include": [
14 |       "src/**/*.ts",
15 |       "mod.ts",
16 |       "README.md",
17 |       "LICENSE"
18 |     ]
19 |   },
20 |   "tasks": {
21 |     "test": "deno test",
22 |     "check": "deno check mod.ts"
23 |   },
24 |   "fmt": {
25 |     "include": ["src/", "mod.ts"],
26 |     "lineWidth": 100,
27 |     "indentWidth": 2
28 |   }
29 | } 


--------------------------------------------------------------------------------
/examples/exchange_api_testing.cjs:
--------------------------------------------------------------------------------
  1 | // test_exchange_api.ts
  2 | 
  3 | const { Hyperliquid } = require("../dist/index");
  4 | const readline = require("readline");
  5 | require("dotenv").config();
  6 | 
  7 | const cloid = "0x1234567890abcdef1234567890abcdef"
  8 | 
  9 | const rl = readline.createInterface({
 10 |   input: process.stdin,
 11 |   output: process.stdout,
 12 | });
 13 | 
 14 | function waitForUserInput(message) {
 15 |   return new Promise((resolve) => {
 16 |     rl.question(message, () => {
 17 |       resolve();
 18 |     });
 19 |   });
 20 | }
 21 | 
 22 | async function testCustomExchangeAPI() {
 23 |   // Initialize the SDK (replace with your actual private key and other necessary parameters)
 24 |   const private_key = process.env.priv_key;
 25 |   const user_address = ""
 26 |   const testnet = false// false for mainnet, true for testnet
 27 |   const vaultAddress = null // or your vault address
 28 |   const sdk = new Hyperliquid({
 29 |     privateKey: private_key,
 30 |     testnet: testnet,
 31 |     walletAddress: user_address,
 32 |     vaultAddress: vaultAddress
 33 |   }); 
 34 | 
 35 |   try {
 36 |     await sdk.initialize();
 37 |     console.log("Testing CustomOperations methods:");
 38 | 
 39 |     // 1. Get All Assets
 40 |     console.log("\n1. Getting All Assets...");
 41 |     const assets = await sdk.custom.getAllAssets();
 42 |     console.log("Available assets:", assets);
 43 |     await waitForUserInput("Press Enter to continue to Market Open...");
 44 | 
 45 |     // 2. Market Open (place a market order)
 46 |     console.log("\n2. Market Open (Buy)...");
 47 |     const marketOpenResponse = await sdk.custom.marketOpen(
 48 |       "SOL-PERP",  // symbol
 49 |       true,        // isBuy
 50 |       0.1,         // size
 51 |     );
 52 |     console.log("Market Open Response:", marketOpenResponse);
 53 |     await waitForUserInput("Press Enter to continue to Market Close...");
 54 | 
 55 |     // 3. Market Close (close a specific position)
 56 |     console.log("\n3. Market Close...");
 57 |     try {
 58 |       const marketCloseResponse = await sdk.custom.marketClose(
 59 |         "SOL-PERP",  // symbol
 60 |       );
 61 |       console.log("Market Close Response:", marketCloseResponse);
 62 |     } catch (error) {
 63 |       console.log("Market Close Error (may occur if no position exists):", error.message);
 64 |       
 65 |       // If no position exists, open a new one to close
 66 |       console.log("Creating a new position to close...");
 67 |       await sdk.custom.marketOpen("SOL-PERP", true, 0.1);
 68 |       const marketCloseResponse = await sdk.custom.marketClose("SOL-PERP");
 69 |       console.log("Market Close Response (after creating position):", marketCloseResponse);
 70 |     }
 71 |     await waitForUserInput("Press Enter to continue to Close All Positions...");
 72 | 
 73 |     // 4. Close All Positions
 74 |     console.log("\n4. Close All Positions...");
 75 |     try {
 76 |       // First create some positions if needed
 77 |       await sdk.custom.marketOpen("SOL-PERP", true, 0.1);
 78 |       await sdk.custom.marketOpen("ETH-PERP", false, 0.01);
 79 |       
 80 |       const closeAllResponse = await sdk.custom.closeAllPositions(0.05); // 5% slippage
 81 |       console.log("Close All Positions Response:", closeAllResponse);
 82 |     } catch (error) {
 83 |       console.log("Close All Positions Error:", error.message);
 84 |     }
 85 |     await waitForUserInput("Press Enter to continue to Cancel All Orders...");
 86 | 
 87 |     // 5. Cancel All Orders
 88 |     console.log("\n5. Cancelling All Orders...");
 89 |     // Place some orders first
 90 |     await sdk.exchange.placeOrder({
 91 |       coin: "SOL-PERP",
 92 |       is_buy: true,
 93 |       sz: 0.1,
 94 |       limit_px: 100.0, // Far from market price to avoid execution
 95 |       order_type: { limit: { tif: "Gtc" } },
 96 |       reduce_only: false,
 97 |       cloid: cloid
 98 |     });
 99 |     
100 |     await sdk.exchange.placeOrder({
101 |       coin: "BTC-PERP",
102 |       is_buy: false,
103 |       sz: 0.001,
104 |       limit_px: 100000.0, // Far from market price to avoid execution
105 |       order_type: { limit: { tif: "Gtc" } },
106 |       reduce_only: false,
107 |       cloid: cloid
108 |     });
109 |     
110 |     const cancelResponse = await sdk.custom.cancelAllOrders();
111 |     console.log("Cancel All Orders Response:", cancelResponse);
112 |     
113 |     // 6. Cancel All Orders for a specific symbol
114 |     console.log("\n6. Cancelling All Orders for a specific symbol...");
115 |     // Place an order first
116 |     await sdk.exchange.placeOrder({
117 |       coin: "ETH-PERP",
118 |       is_buy: true,
119 |       sz: 0.01,
120 |       limit_px: 1000.0, // Far from market price to avoid execution
121 |       order_type: { limit: { tif: "Gtc" } },
122 |       reduce_only: false,
123 |       cloid: cloid
124 |     });
125 |     
126 |     const cancelSymbolResponse = await sdk.custom.cancelAllOrders("ETH-PERP");
127 |     console.log("Cancel Symbol Orders Response:", cancelSymbolResponse);
128 |     
129 |   } catch (error) {
130 |     console.error("An error occurred:", error);
131 |   } finally {
132 |     rl.close();
133 |   }
134 | }
135 | 
136 | async function testExchangeAPI() {
137 |   // Initialize the SDK (replace with your actual private key and other necessary parameters)
138 |   const private_key = process.env.priv_key;
139 |   const user_address = ""
140 |   const testnet = false// false for mainnet, true for testnet
141 |   const vaultAddress = null // or your vault address
142 |   const sdk = new Hyperliquid({
143 |     privateKey: private_key,
144 |     testnet: testnet,
145 |     walletAddress: user_address,
146 |     vaultAddress: vaultAddress
147 |   }); 
148 |   try {
149 |     console.log("Testing ExchangeAPI endpoints:");
150 | 
151 | 
152 |     await waitForUserInput("Press Enter to continue to Place Order...");
153 | 
154 |     // 1. Place Order
155 |     const orderRequest = {
156 |       coin: "SOL-PERP",
157 |       is_buy: true,
158 |       sz: 0.30,
159 |       limit_px: 127.500000000,
160 |       order_type: { limit: { tif: "Gtc" } },
161 |       reduce_only: false,
162 |       cloid: cloid
163 |     };
164 | 
165 |     // If you want to place multiple orders, you need to call placeOrder separately for each order
166 |     // const secondOrderRequest = {
167 |     //   coin: "SOL-PERP",
168 |     //   is_buy: false,
169 |     //   sz: 0.2,
170 |     //   limit_px: 125.15,
171 |     //   order_type: { limit: { tif: "Gtc" } },
172 |     //   reduce_only: false,
173 |     //   cloid: cloid
174 |     // };
175 | 
176 |     await sdk.initialize();
177 |     const state = await sdk.info.perpetuals.getClearinghouseState(user_address);
178 |     console.log('Account Value:', state.marginSummary.accountValue);
179 | 
180 |     // const approveFeeResponse = await sdk.exchange.approveBuilderFee({
181 |     //   builder: "0xd272c0adCc36f5bAEF44BCcEa23A61E9cc6B8EF3",
182 |     //   maxFeeRate: "0.01%",
183 |     // });
184 |     // console.log(approveFeeResponse);
185 |     
186 | 
187 |     console.log("\n1. Place Order:");
188 |     const placeOrderResponse = await sdk.exchange.placeOrder(orderRequest);
189 |     console.log(JSON.stringify(placeOrderResponse));
190 |     await waitForUserInput("Press Enter to continue to Cancel Order...");
191 | 
192 |     // 2. Cancel Order
193 |     const cancelRequest = {
194 |       coin: "SOL-PERP",
195 |       o: placeOrderResponse.response.data.statuses[0].resting.oid, // assuming this is where the order ID is
196 |     };
197 |     console.log("\n2. Cancel Order:");
198 |     const cancelOrderResponse = await sdk.exchange.cancelOrder(cancelRequest);
199 |     console.log(JSON.stringify(cancelOrderResponse));
200 |     await waitForUserInput(
201 |       "Press Enter to continue to Cancel Order by CLOID..."
202 |     );
203 | 
204 |     // 3. Cancel Order by CLOID
205 |     console.log("\n3. Cancel Order by CLOID:");
206 |     const placeOrderResponse2 = await sdk.exchange.placeOrder(orderRequest);
207 |     console.log(JSON.stringify(placeOrderResponse2));
208 |     const cancelByCloidResponse = await sdk.exchange.cancelOrderByCloid(
209 |       "SOL-PERP",
210 |       cloid
211 |     );
212 |     console.log(JSON.stringify(cancelByCloidResponse));
213 |     await waitForUserInput("Press Enter to continue to Modify Order...");
214 | 
215 |     // 4. Modify Order
216 |     console.log("\n4. Modify Order:");
217 |     const modifyOrderResponse = await sdk.exchange.modifyOrder(
218 |       placeOrderResponse.response.data.statuses[0].resting.oid,
219 |       {
220 |         ...orderRequest,
221 |         limit_px: 121.49,
222 |       }
223 |     );
224 |     console.log(modifyOrderResponse);
225 |     await waitForUserInput("Press Enter to continue to Batch Modify Orders...");
226 | 
227 |     // 5. Batch Modify Orders
228 |     console.log("\n5. Batch Modify Orders:");
229 |     const batchModifyResponse = await sdk.exchange.batchModifyOrders([
230 |       {
231 |         oid: placeOrderResponse.response.data.statuses[0].resting.oid,
232 |         order: { ...orderRequest, limit_px: 155.3 },
233 |       },
234 |     ]);
235 |     console.log(batchModifyResponse);
236 |     console.log(batchModifyResponse.response.data.statuses);
237 |     await waitForUserInput("Press Enter to continue to Update Leverage...");
238 | 
239 |     // 6. Update Leverage
240 |     console.log("\n6. Update Leverage:");
241 |     const updateLeverageResponse = await sdk.exchange.updateLeverage(
242 |       "SOL-PERP",
243 |       "isolated",
244 |       15
245 |     );
246 |     console.log(updateLeverageResponse);
247 |     await waitForUserInput(
248 |       "Press Enter to continue to Update Isolated Margin..."
249 |     );
250 | 
251 |     // 7. Update Isolated Margin
252 |     console.log("\n7. Update Isolated Margin:");
253 |     const updateMarginResponse = await sdk.exchange.updateIsolatedMargin(
254 |       "BTC-PERP",
255 |       true,
256 |       100
257 |     );
258 |     console.log(updateMarginResponse);
259 |     await waitForUserInput("Press Enter to continue to USD Transfer...");
260 | 
261 |     // 8. USD Transfer
262 |     console.log("\n8. USD Transfer:");
263 |     const usdTransferResponse = await sdk.exchange.usdTransfer(
264 |       "",
265 |       12
266 |     );
267 |     console.log(usdTransferResponse);
268 |     await waitForUserInput("Press Enter to continue to Spot Transfer...");
269 | 
270 |     // 9. Spot Transfer --
271 |     console.log("\n9. Spot Transfer:");
272 |     const spotTransferResponse = await sdk.exchange.spotTransfer(
273 |       "",
274 |       "PURR-SPOT",
275 |       "0.001"
276 |     );
277 |     console.log(spotTransferResponse);
278 |     await waitForUserInput("Press Enter to continue to Initiate Withdrawal...");
279 | 
280 |     // 10. Initiate Withdrawal --
281 |     console.log("\n10. Initiate Withdrawal:");
282 |     const withdrawalResponse = await sdk.exchange.initiateWithdrawal(
283 |       "",
284 |       15.14
285 |     );
286 |     console.log(withdrawalResponse);
287 |     await waitForUserInput(
288 |       "Press Enter to continue to Transfer Between Spot and Perp..."
289 |     );
290 | 
291 |     // 11. Transfer Between Spot and Perp
292 |     console.log("\n11. Transfer Between Spot and Perp:");
293 | 
294 |     const transferResponse = await sdk.exchange.transferBetweenSpotAndPerp(0.1, true);
295 |     console.log(transferResponse);
296 |     await waitForUserInput("Press Enter to continue to Schedule Cancel...");
297 | 
298 |     // 12. Schedule Cancel
299 |     console.log("\n12. Schedule Cancel:");
300 |     const scheduleCancelResponse = await sdk.exchange.scheduleCancel(
301 |       Date.now() + 3600000
302 |     ); // Cancel in 1 hour
303 |     console.log(scheduleCancelResponse);
304 |     await waitForUserInput("Press Enter to continue to Vault Transfer...");
305 | 
306 |     // 13. Vault Transfer
307 |     console.log("\n13. Vault Transfer:");
308 |     const vaultTransferResponse = await sdk.exchange.vaultTransfer(
309 |       "",
310 |       true,
311 |       4
312 |     );
313 |     console.log(vaultTransferResponse);
314 |     await waitForUserInput("Press Enter to continue to Set Referrer...");
315 | 
316 |     // 14. Set Referrer
317 |     console.log("\n14. Set Referrer:");
318 |     const setReferrerResponse = await sdk.exchange.setReferrer(
319 |       "referrer_code_here"
320 |     );
321 |     console.log(setReferrerResponse);
322 | 
323 |     await waitForUserInput("Press Enter to continue to Place TWAP order...");
324 | 
325 |     // 15. Place TWAP order 
326 |     console.log("\n15. Place TWAP order:");
327 |     const twapOrderResponse = await sdk.exchange.placeTwapOrder({
328 |       coin: "BTC-PERP",
329 |       is_buy: true,
330 |       sz: 0.001,
331 |       reduce_only: false,
332 |       minutes: 10,
333 |       randomize: false
334 |     });
335 |     console.log(twapOrderResponse);
336 | 
337 |     await waitForUserInput("Press Enter to continue to Cancel TWAP order...");
338 | 
339 |     // 16. Cancel TWAP order
340 |     console.log("\n16. Cancel TWAP order:");
341 |     const cancelTwapOrderResponse = await sdk.exchange.cancelTwapOrder(twapOrderResponse.response.data.status.running.twapId);
342 |     console.log(cancelTwapOrderResponse);
343 |   } catch (error) {
344 |     console.error("An error occurred:", error);
345 |   } finally {
346 |     rl.close();
347 |   }
348 | 
349 |   // 17. Approve Agent
350 |   console.log("\n17. Approve Agent:");
351 |   const approveAgentResponse = await sdk.exchange.approveAgent({
352 |     agentAddress : "0x1234567890123456789012345678901234567890", //Replace this with a valid agentAddress, can generate one from the Hyperliquid UI
353 |     agentName    : "testAgent1" // Optional, just a name so you can identify the agent wallet, max 1 unnammed api agent and 2-3 named ones allowed
354 |   });
355 |   console.log(approveAgentResponse);
356 | 
357 |   await waitForUserInput("Press Enter to continue to Approve Builder Fee...");
358 | 
359 |   // 18. Approve Builder Fee
360 |   console.log("\n18. Approve Builder Fee:");
361 |   const approveBuilderFeeResponse = await sdk.exchange.approveBuilderFee({
362 |     maxFeeRate : "0.001%", // 0.001% fee rate
363 |     builder    : "0x1234567890123456789012345678901234567890"
364 |   });
365 |   console.log(approveBuilderFeeResponse);
366 | 
367 |   await waitForUserInput("Press Enter to continue to Modify User EVM...");
368 | 
369 |   // 19. Modify User EVM
370 |   console.log("\n19. Modify User EVM:");
371 |   const modifyUserEvmResponse = await sdk.exchange.modifyUserEvm(true);
372 |   console.log(modifyUserEvmResponse);
373 | 
374 |   await waitForUserInput("Press Enter to continue to Deposit to Staking...");
375 | }
376 | 
377 | testCustomExchangeAPI();
378 | // testExchangeAPI();
379 | 


--------------------------------------------------------------------------------
/examples/info_api_testing.cjs:
--------------------------------------------------------------------------------
  1 | const { Hyperliquid } = require('../dist/index');
  2 | const readline = require('readline');
  3 | 
  4 | const private_key = "";
  5 | const user_address = "0xd852e3a7a2abca6aecd0fa39147851ae96eba5d7";
  6 | 
  7 | const raw_mode = true;
  8 | 
  9 | const rl = readline.createInterface({
 10 |     input: process.stdin,
 11 |     output: process.stdout
 12 | });
 13 | 
 14 | function waitForInput(prompt) {
 15 |     return new Promise((resolve) => {
 16 |         rl.question(prompt, () => {
 17 |             resolve();
 18 |         });
 19 |     });
 20 | }
 21 | 
 22 | async function testInfoAPI(sdk) {
 23 |     console.log("Testing InfoAPI methods:");
 24 |     
 25 |     console.log("getAllMids:");
 26 |     console.log(await sdk.info.getAllMids(raw_mode));
 27 |     await waitForInput("Press Enter to continue...");
 28 | 
 29 |     console.log("getUserOpenOrders:");
 30 |     console.log(await sdk.info.getUserOpenOrders(user_address, raw_mode));
 31 |     await waitForInput("Press Enter to continue...");
 32 | 
 33 |     console.log("getFrontendOpenOrders:");
 34 |     console.log(await sdk.info.getFrontendOpenOrders(user_address, raw_mode));
 35 |     await waitForInput("Press Enter to continue...");
 36 | 
 37 |     console.log("getUserFills:");
 38 |     console.log(await sdk.info.getUserFills(user_address, raw_mode));
 39 |     await waitForInput("Press Enter to continue...");
 40 | 
 41 |     console.log("getUserFillsByTime:");
 42 |     console.log(await sdk.info.getUserFillsByTime(user_address, Date.now() - 1506400000, Date.now(), raw_mode)); // Last 24 hours
 43 |     await waitForInput("Press Enter to continue...");
 44 | 
 45 |     console.log("getUserRateLimit:");
 46 |     console.log(await sdk.info.getUserRateLimit(user_address, raw_mode));
 47 |     await waitForInput("Press Enter to continue...");
 48 | 
 49 |     console.log("getOrderStatus:");
 50 |     console.log(await sdk.info.getOrderStatus(user_address, 1000, raw_mode));
 51 |     await waitForInput("Press Enter to continue...");
 52 | 
 53 |     console.log("getL2Book:");
 54 |     const book = await sdk.info.getL2Book("BTC-PERP", raw_mode)
 55 |     console.log(book)
 56 |     console.log(book.levels)
 57 |     await waitForInput("Press Enter to continue...");
 58 | 
 59 |     console.log("getCandleSnapshot:");
 60 |     console.log(await sdk.info.getCandleSnapshot("BTC-PERP", "1h", Date.now() - 86400000, Date.now(), raw_mode));
 61 |     await waitForInput("Press Enter to continue...");
 62 | 
 63 |     // console.log("getMaxBuilderFee:");
 64 |     // console.log(await sdk.info.getMaxBuilderFee(user_address, "", raw_mode));
 65 |     // await waitForInput("Press Enter to continue...");
 66 | 
 67 |     console.log("getHistoricalOrders:");
 68 |     console.log(await sdk.info.getHistoricalOrders(user_address, raw_mode));
 69 |     await waitForInput("Press Enter to continue...");
 70 | 
 71 |     console.log("getUserTwapSliceFills:");
 72 |     console.log(await sdk.info.getUserTwapSliceFills(user_address, raw_mode));
 73 |     await waitForInput("Press Enter to continue...");
 74 | 
 75 |     console.log("getSubAccounts:");
 76 |     console.log(await sdk.info.getSubAccounts(user_address, raw_mode));
 77 |     await waitForInput("Press Enter to continue...");
 78 | 
 79 |     console.log("getVaultDetails:");
 80 |     const vaultAddress = ""; // Replace with actual vault address
 81 |     console.log(await sdk.info.getVaultDetails(vaultAddress, user_address, raw_mode));
 82 |     await waitForInput("Press Enter to continue...");
 83 | 
 84 |     console.log("getUserVaultEquities:");
 85 |     console.log(await sdk.info.getUserVaultEquities(user_address, raw_mode));
 86 |     await waitForInput("Press Enter to continue...");
 87 | 
 88 |     console.log("getUserRole:");
 89 |     console.log(await sdk.info.getUserRole(user_address, raw_mode));
 90 |     await waitForInput("Press Enter to continue...");
 91 | 
 92 |     console.log("getDelegations:");
 93 |     console.log(await sdk.info.getDelegations(user_address, raw_mode));
 94 |     await waitForInput("Press Enter to continue...");
 95 | 
 96 |     console.log("getDelegatorSummary:");
 97 |     console.log(await sdk.info.getDelegatorSummary(user_address, raw_mode));
 98 |     await waitForInput("Press Enter to continue...");
 99 | 
100 |     console.log("getDelegatorHistory:");
101 |     console.log(await sdk.info.getDelegatorHistory(user_address, raw_mode));
102 |     await waitForInput("Press Enter to continue...");
103 | 
104 |     console.log("getDelegatorRewards:");
105 |     console.log(await sdk.info.getDelegatorRewards(user_address, raw_mode));
106 |     await waitForInput("Press Enter to continue...");
107 | 
108 |     // New methods tests
109 |     console.log("validatorSummaries:");
110 |     console.log(await sdk.info.validatorSummaries(raw_mode));
111 |     await waitForInput("Press Enter to continue...");
112 | 
113 |     console.log("vaultSummaries:");
114 |     console.log(await sdk.info.vaultSummaries(raw_mode));
115 |     await waitForInput("Press Enter to continue...");
116 | 
117 |     console.log("userFees:");
118 |     console.log(await sdk.info.userFees(user_address, raw_mode));
119 |     await waitForInput("Press Enter to continue...");
120 | 
121 |     console.log("portfolio:");
122 |     console.log(await sdk.info.portfolio(user_address, raw_mode));
123 |     await waitForInput("Press Enter to continue...");
124 | 
125 |     console.log("preTransferCheck:");
126 |     // Source is typically another user address
127 |     const sourceAddress = "0x0000000000000000000000000000000000000000";
128 |     console.log(await sdk.info.preTransferCheck(user_address, sourceAddress, raw_mode));
129 |     await waitForInput("Press Enter to continue...");
130 | 
131 |     console.log("referral:");
132 |     console.log(await sdk.info.referral(user_address, raw_mode));
133 |     await waitForInput("Press Enter to continue...");
134 | 
135 |     console.log("extraAgents:");
136 |     console.log(await sdk.info.extraAgents(user_address, raw_mode));
137 |     await waitForInput("Press Enter to continue...");
138 | 
139 |     console.log("isVip:");
140 |     console.log(await sdk.info.isVip(user_address, raw_mode));
141 |     await waitForInput("Press Enter to continue...");
142 | 
143 |     console.log("legalCheck:");
144 |     console.log(await sdk.info.legalCheck(user_address, raw_mode));
145 |     await waitForInput("Press Enter to continue...");
146 | 
147 |     console.log("userTwapSliceFillsByTime:");
148 |     console.log(await sdk.info.userTwapSliceFillsByTime(
149 |         user_address, 
150 |         Date.now() - 86400000, // 24 hours ago
151 |         Date.now(),           // now
152 |         false,                // don't aggregate by time
153 |         raw_mode
154 |     ));
155 |     await waitForInput("Press Enter to continue...");
156 | 
157 |     console.log("twapHistory:");
158 |     console.log(await sdk.info.twapHistory(user_address, raw_mode));
159 |     await waitForInput("Press Enter to continue...");
160 | 
161 |     console.log("userToMultiSigSigners:");
162 |     console.log(await sdk.info.userToMultiSigSigners(user_address, raw_mode));
163 |     await waitForInput("Press Enter to continue...");
164 | }
165 | 
166 | async function testSpotInfoAPI(sdk) {
167 |     console.log("\nTesting SpotInfoAPI methods:");
168 |     
169 |     console.log("getSpotMeta:");
170 |     console.log(await sdk.info.spot.getSpotMeta(raw_mode));
171 |     await waitForInput("Press Enter to continue...");
172 | 
173 |     console.log("getSpotClearinghouseState:");
174 |     console.log(await sdk.info.spot.getSpotClearinghouseState(user_address, raw_mode));
175 |     await waitForInput("Press Enter to continue...");
176 | 
177 |     console.log("getSpotMetaAndAssetCtxs:");
178 |     console.log(await sdk.info.spot.getSpotMetaAndAssetCtxs(raw_mode));
179 |     await waitForInput("Press Enter to continue...");
180 | 
181 |     console.log("getTokenDetails:");
182 |     console.log(await sdk.info.spot.getTokenDetails("", raw_mode)); //using PURR as example
183 |     await waitForInput("Press Enter to continue...");
184 | 
185 |     console.log("getSpotDeployState:");
186 |     console.log(await sdk.info.spot.getSpotDeployState(user_address, raw_mode));
187 |     await waitForInput("Press Enter to continue...");
188 | }
189 | 
190 | async function testPerpetualsInfoAPI(sdk) {
191 |     console.log("\nTesting PerpetualsInfoAPI methods:");
192 |     
193 |     console.log("getMeta:");
194 |     console.log(await sdk.info.perpetuals.getMeta(raw_mode));
195 |     await waitForInput("Press Enter to continue...");
196 | 
197 |     console.log("getMetaAndAssetCtxs:");
198 |     console.log(await sdk.info.perpetuals.getMetaAndAssetCtxs(raw_mode));
199 |     await waitForInput("Press Enter to continue...");
200 | 
201 |     console.log("getClearinghouseState:");
202 |     const perpsClearing = await sdk.info.perpetuals.getClearinghouseState(user_address, raw_mode);
203 |     console.log(perpsClearing);
204 |     console.log(perpsClearing.assetPositions)
205 |     await waitForInput("Press Enter to continue...");
206 | 
207 |     console.log("getUserFunding:");
208 |     console.log(await sdk.info.perpetuals.getUserFunding(user_address, Date.now() - 86400000, Date.now(), raw_mode));
209 |     await waitForInput("Press Enter to continue...");
210 | 
211 |     console.log("getUserNonFundingLedgerUpdates:");
212 |     console.log(await sdk.info.perpetuals.getUserNonFundingLedgerUpdates(user_address, Date.now() - 86400000, Date.now(), raw_mode));
213 |     await waitForInput("Press Enter to continue...");
214 | 
215 |     // await sdk.connect() // Need to connect/initialize SDK symbols map before using internal symbol mappings
216 | 
217 |     console.log("getFundingHistory:");
218 |     console.log(await sdk.info.perpetuals.getFundingHistory("BTC-PERP", Date.now() - 86400000, Date.now(), raw_mode));
219 |     await waitForInput("Press Enter to continue...");
220 | 
221 |     console.log("getPredictedFundings:");
222 |     console.log(await sdk.info.perpetuals.getPredictedFundings(raw_mode));
223 |     await waitForInput("Press Enter to continue...");
224 | 
225 |     console.log("getPerpsAtOpenInterestCap:");
226 |     console.log(await sdk.info.perpetuals.getPerpsAtOpenInterestCap(raw_mode));
227 |     await waitForInput("Press Enter to continue...")
228 | }
229 | 
230 | async function main() {
231 |     const sdk = new Hyperliquid({
232 |         privateKey: private_key
233 |     });
234 | 
235 |     try {
236 |         // Initialize the SDK before using any methods
237 |         // await sdk.connect();
238 |         
239 |         await testInfoAPI(sdk);
240 |         await testSpotInfoAPI(sdk);
241 |         await testPerpetualsInfoAPI(sdk);
242 |     } catch (error) {
243 |         console.error('An error occurred:', error);
244 |     } finally {
245 |         rl.close();
246 |     }
247 | }
248 | 
249 | main();


--------------------------------------------------------------------------------
/examples/ws_test.cjs:
--------------------------------------------------------------------------------
 1 | 
 2 | /*
 3 |  * @Author: Nw1996
 4 |  * @Date: 2025-01-27 09:08:46
 5 |  * @LastEditors: Nw1996
 6 |  * @LastEditTime: 2025-01-27 12:05:11
 7 |  * @Description: 
 8 |  * @FilePath: /hyperliquid/examples/ws_test.cjs
 9 |  */
10 | const { Hyperliquid } = require("../dist/index.cjs");
11 | 
12 | const private_key = "";
13 | const user_address = "0x2711ce5de8b2Ddc8079622079A2fa1457dA78306"
14 | const testnet = true// false for mainnet, true for testnet
15 | const vaultAddress = null // or your vault address
16 | const hlsdk = new Hyperliquid({
17 |     privateKey: private_key,
18 |     testnet: testnet,
19 |     walletAddress: user_address,
20 |     vaultAddress: vaultAddress,
21 |     maxReconnectAttempts: 100
22 | });
23 | function subInfos() {
24 |     hlsdk.subscriptions.subscribeToAllMids((data) => {
25 |         console.log('===subscribeToAllMids===>HYPE-SPOT', data['HYPE-SPOT']);
26 |     });
27 |     hlsdk.subscriptions.subscribeToUserFills(user_address, (data) => {
28 |         console.log('===subscribeToUserFills===', data.fills[0]);
29 |     });
30 |     hlsdk.subscriptions.subscribeToOrderUpdates(user_address, (data => {
31 |         data.map(async v => {
32 |             console.log('===subscribeToOrderUpdates===', v)
33 |         })
34 |     }))
35 | }
36 | async function testWs() {
37 |     try {
38 |         await hlsdk.connect();
39 |         console.log('Connected to WebSocket');
40 |         subInfos()
41 |         setTimeout(() => {
42 |             console.log('User CancleConnected to WebSocket');
43 |             hlsdk.disconnect()
44 |         }, 5*1000);
45 |         // reconnect
46 |         hlsdk.ws.on('reconnect', () => {
47 |             subInfos()
48 |         })
49 | 
50 |         
51 |     } catch (error) {
52 |         console.error('Error:', error);
53 |     }
54 | }
55 | testWs()
56 | // output
57 | // WebSocket connected
58 | // Connected to WebSocket
59 | // ===subscribeToUserFills=== undefined
60 | // ===subscribeToAllMids===>HYPE-SPOT 145.305
61 | // ===subscribeToAllMids===>HYPE-SPOT 145.305
62 | // ===subscribeToAllMids===>HYPE-SPOT 145.305
63 | // User CancleConnected to WebSocket
64 | // WebSocket disconnected
65 | // Attempting to reconnect (1/100) in 1000ms...
66 | // WebSocket connected
67 | // ===subscribeToUserFills=== undefined
68 | // ===subscribeToAllMids===>HYPE-SPOT 145.305
69 | // ===subscribeToAllMids===>HYPE-SPOT 145.305
70 | // ===subscribeToAllMids===>HYPE-SPOT 145.305


--------------------------------------------------------------------------------
/mod.ts:
--------------------------------------------------------------------------------
1 | // Re-export everything from the main module
2 | export * from "./src/index.ts";
3 | 
4 | // Export the default Hyperliquid class
5 | export { Hyperliquid as default } from "./src/index.ts"; 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "hyperliquid",
 3 |   "version": "1.7.5",
 4 |   "description": "SDK for Hyperliquid API",
 5 |   "main": "./dist/index.js",
 6 |   "module": "./dist/index.mjs",
 7 |   "types": "./dist/index.d.ts",
 8 |   "exports": {
 9 |     ".": {
10 |       "types": "./dist/index.d.ts",
11 |       "browser": "./dist/browser.js",
12 |       "require": "./dist/index.js",
13 |       "import": "./dist/index.mjs"
14 |     }
15 |   },
16 |   "browser": {
17 |     "./dist/index.js": "./dist/browser.js"
18 |   },
19 |   "files": [
20 |     "dist",
21 |     "src",
22 |     "README.md",
23 |     "LICENSE"
24 |   ],
25 |   "sideEffects": false,
26 |   "scripts": {
27 |     "prebuild": "npm run format",
28 |     "build": "tsup",
29 |     "test": "jest",
30 |     "prepare": "husky install && npm run build",
31 |     "test:node": "node examples/node-test.js",
32 |     "test:browser": "npx serve -s . -p 3000",
33 |     "test:all": "npm run build && npm run test:node && echo '\nTo test in browser, run: npm run test:browser and visit http://localhost:3000/examples/browser-test.html'",
34 |     "format": "prettier --write \"src/**/*.{ts,tsx,js,jsx}\"",
35 |     "format:check": "prettier --check \"src/**/*.{ts,tsx,js,jsx}\"",
36 |     "format:all": "prettier --write \"**/*.{ts,tsx,js,jsx,json,md}\"",
37 |     "postinstall": "husky install"
38 |   },
39 |   "keywords": [
40 |     "hyperliquid",
41 |     "api",
42 |     "sdk",
43 |     "rest",
44 |     "websocket",
45 |     "trading",
46 |     "crypto",
47 |     "blockchain",
48 |     "arbitrum",
49 |     "dex"
50 |   ],
51 |   "author": "Nomeida",
52 |   "license": "MIT",
53 |   "dependencies": {
54 |     "@msgpack/msgpack": "^3.0.0-beta2",
55 |     "axios": "^1.7.2",
56 |     "ethers": "^6.13.2"
57 |   },
58 |   "devDependencies": {
59 |     "@types/jest": "^29.0.0",
60 |     "husky": "^9.1.7",
61 |     "jest": "^29.0.0",
62 |     "lint-staged": "^15.5.1",
63 |     "prettier": "^3.5.3",
64 |     "serve": "^14.0.0",
65 |     "tsup": "^8.0.0",
66 |     "typescript": "^5.0.0"
67 |   },
68 |   "directories": {
69 |     "test": "tests"
70 |   },
71 |   "repository": {
72 |     "type": "git",
73 |     "url": "https://github.com/nomeida/hyperliquid-api"
74 |   },
75 |   "engines": {
76 |     "node": ">=16.0.0"
77 |   },
78 |   "lint-staged": {
79 |     "*.{ts,tsx,js,jsx}": [
80 |       "prettier --write"
81 |     ],
82 |     "*.{json,md}": [
83 |       "prettier --write"
84 |     ]
85 |   }
86 | }
87 | 


--------------------------------------------------------------------------------
/pnpm-lock.yaml:
--------------------------------------------------------------------------------
  1 | lockfileVersion: '9.0'
  2 | 
  3 | settings:
  4 |   autoInstallPeers: true
  5 |   excludeLinksFromLockfile: false
  6 | 
  7 | importers:
  8 | 
  9 |   .:
 10 |     dependencies:
 11 |       '@msgpack/msgpack':
 12 |         specifier: ^3.0.0-beta2
 13 |         version: 3.0.0-beta2
 14 |       '@types/ws':
 15 |         specifier: ^8.5.11
 16 |         version: 8.5.12
 17 |       axios:
 18 |         specifier: ^1.7.2
 19 |         version: 1.7.7
 20 |       ethers:
 21 |         specifier: ^6.13.2
 22 |         version: 6.13.2
 23 |       typescript:
 24 |         specifier: ^5.5.4
 25 |         version: 5.6.2
 26 |       ws:
 27 |         specifier: ^8.18.0
 28 |         version: 8.18.0
 29 |     devDependencies:
 30 |       dotenv:
 31 |         specifier: ^16.4.5
 32 |         version: 16.4.5
 33 | 
 34 | packages:
 35 | 
 36 |   '@adraffy/ens-normalize@1.10.1':
 37 |     resolution: {integrity: sha512-96Z2IP3mYmF1Xg2cDm8f1gWGf/HUVedQ3FMifV4kG/PQ4yEP51xDtRAEfhVNt5f/uzpNkZHwWQuUcu6D6K+Ekw==, tarball: https://registry.npmmirror.com/@adraffy/ens-normalize/-/ens-normalize-1.10.1.tgz}
 38 | 
 39 |   '@msgpack/msgpack@3.0.0-beta2':
 40 |     resolution: {integrity: sha512-y+l1PNV0XDyY8sM3YtuMLK5vE3/hkfId+Do8pLo/OPxfxuFAUwcGz3oiiUuV46/aBpwTzZ+mRWVMtlSKbradhw==, tarball: https://registry.npmmirror.com/@msgpack/msgpack/-/msgpack-3.0.0-beta2.tgz}
 41 |     engines: {node: '>= 14'}
 42 | 
 43 |   '@noble/curves@1.2.0':
 44 |     resolution: {integrity: sha512-oYclrNgRaM9SsBUBVbb8M6DTV7ZHRTKugureoYEncY5c65HOmRzvSiTE3y5CYaPYJA/GVkrhXEoF0M3Ya9PMnw==, tarball: https://registry.npmmirror.com/@noble/curves/-/curves-1.2.0.tgz}
 45 | 
 46 |   '@noble/hashes@1.3.2':
 47 |     resolution: {integrity: sha512-MVC8EAQp7MvEcm30KWENFjgR+Mkmf+D189XJTkFIlwohU5hcBbn1ZkKq7KVTi2Hme3PMGF390DaL52beVrIihQ==, tarball: https://registry.npmmirror.com/@noble/hashes/-/hashes-1.3.2.tgz}
 48 |     engines: {node: '>= 16'}
 49 | 
 50 |   '@types/node@18.15.13':
 51 |     resolution: {integrity: sha512-N+0kuo9KgrUQ1Sn/ifDXsvg0TTleP7rIy4zOBGECxAljqvqfqpTfzx0Q1NUedOixRMBfe2Whhb056a42cWs26Q==, tarball: https://registry.npmmirror.com/@types/node/-/node-18.15.13.tgz}
 52 | 
 53 |   '@types/node@22.5.5':
 54 |     resolution: {integrity: sha512-Xjs4y5UPO/CLdzpgR6GirZJx36yScjh73+2NlLlkFRSoQN8B0DpfXPdZGnvVmLRLOsqDpOfTNv7D9trgGhmOIA==, tarball: https://registry.npmmirror.com/@types/node/-/node-22.5.5.tgz}
 55 | 
 56 |   '@types/ws@8.5.12':
 57 |     resolution: {integrity: sha512-3tPRkv1EtkDpzlgyKyI8pGsGZAGPEaXeu0DOj5DI25Ja91bdAYddYHbADRYVrZMRbfW+1l5YwXVDKohDJNQxkQ==, tarball: https://registry.npmmirror.com/@types/ws/-/ws-8.5.12.tgz}
 58 | 
 59 |   aes-js@4.0.0-beta.5:
 60 |     resolution: {integrity: sha512-G965FqalsNyrPqgEGON7nIx1e/OVENSgiEIzyC63haUMuvNnwIgIjMs52hlTCKhkBny7A2ORNlfY9Zu+jmGk1Q==, tarball: https://registry.npmmirror.com/aes-js/-/aes-js-4.0.0-beta.5.tgz}
 61 | 
 62 |   asynckit@0.4.0:
 63 |     resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==, tarball: https://registry.npmmirror.com/asynckit/-/asynckit-0.4.0.tgz}
 64 | 
 65 |   axios@1.7.7:
 66 |     resolution: {integrity: sha512-S4kL7XrjgBmvdGut0sN3yJxqYzrDOnivkBiN0OFs6hLiUam3UPvswUo0kqGyhqUZGEOytHyumEdXsAkgCOUf3Q==, tarball: https://registry.npmmirror.com/axios/-/axios-1.7.7.tgz}
 67 | 
 68 |   combined-stream@1.0.8:
 69 |     resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==, tarball: https://registry.npmmirror.com/combined-stream/-/combined-stream-1.0.8.tgz}
 70 |     engines: {node: '>= 0.8'}
 71 | 
 72 |   delayed-stream@1.0.0:
 73 |     resolution: {integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==, tarball: https://registry.npmmirror.com/delayed-stream/-/delayed-stream-1.0.0.tgz}
 74 |     engines: {node: '>=0.4.0'}
 75 | 
 76 |   dotenv@16.4.5:
 77 |     resolution: {integrity: sha512-ZmdL2rui+eB2YwhsWzjInR8LldtZHGDoQ1ugH85ppHKwpUHL7j7rN0Ti9NCnGiQbhaZ11FpR+7ao1dNsmduNUg==, tarball: https://registry.npmmirror.com/dotenv/-/dotenv-16.4.5.tgz}
 78 |     engines: {node: '>=12'}
 79 | 
 80 |   ethers@6.13.2:
 81 |     resolution: {integrity: sha512-9VkriTTed+/27BGuY1s0hf441kqwHJ1wtN2edksEtiRvXx+soxRX3iSXTfFqq2+YwrOqbDoTHjIhQnjJRlzKmg==, tarball: https://registry.npmmirror.com/ethers/-/ethers-6.13.2.tgz}
 82 |     engines: {node: '>=14.0.0'}
 83 | 
 84 |   follow-redirects@1.15.9:
 85 |     resolution: {integrity: sha512-gew4GsXizNgdoRyqmyfMHyAmXsZDk6mHkSxZFCzW9gwlbtOW44CDtYavM+y+72qD/Vq2l550kMF52DT8fOLJqQ==, tarball: https://registry.npmmirror.com/follow-redirects/-/follow-redirects-1.15.9.tgz}
 86 |     engines: {node: '>=4.0'}
 87 |     peerDependencies:
 88 |       debug: '*'
 89 |     peerDependenciesMeta:
 90 |       debug:
 91 |         optional: true
 92 | 
 93 |   form-data@4.0.0:
 94 |     resolution: {integrity: sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==, tarball: https://registry.npmmirror.com/form-data/-/form-data-4.0.0.tgz}
 95 |     engines: {node: '>= 6'}
 96 | 
 97 |   mime-db@1.52.0:
 98 |     resolution: {integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==, tarball: https://registry.npmmirror.com/mime-db/-/mime-db-1.52.0.tgz}
 99 |     engines: {node: '>= 0.6'}
100 | 
101 |   mime-types@2.1.35:
102 |     resolution: {integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==, tarball: https://registry.npmmirror.com/mime-types/-/mime-types-2.1.35.tgz}
103 |     engines: {node: '>= 0.6'}
104 | 
105 |   proxy-from-env@1.1.0:
106 |     resolution: {integrity: sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==, tarball: https://registry.npmmirror.com/proxy-from-env/-/proxy-from-env-1.1.0.tgz}
107 | 
108 |   tslib@2.4.0:
109 |     resolution: {integrity: sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ==, tarball: https://registry.npmmirror.com/tslib/-/tslib-2.4.0.tgz}
110 | 
111 |   typescript@5.6.2:
112 |     resolution: {integrity: sha512-NW8ByodCSNCwZeghjN3o+JX5OFH0Ojg6sadjEKY4huZ52TqbJTJnDo5+Tw98lSy63NZvi4n+ez5m2u5d4PkZyw==, tarball: https://registry.npmmirror.com/typescript/-/typescript-5.6.2.tgz}
113 |     engines: {node: '>=14.17'}
114 |     hasBin: true
115 | 
116 |   undici-types@6.19.8:
117 |     resolution: {integrity: sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==, tarball: https://registry.npmmirror.com/undici-types/-/undici-types-6.19.8.tgz}
118 | 
119 |   ws@8.17.1:
120 |     resolution: {integrity: sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ==, tarball: https://registry.npmmirror.com/ws/-/ws-8.17.1.tgz}
121 |     engines: {node: '>=10.0.0'}
122 |     peerDependencies:
123 |       bufferutil: ^4.0.1
124 |       utf-8-validate: '>=5.0.2'
125 |     peerDependenciesMeta:
126 |       bufferutil:
127 |         optional: true
128 |       utf-8-validate:
129 |         optional: true
130 | 
131 |   ws@8.18.0:
132 |     resolution: {integrity: sha512-8VbfWfHLbbwu3+N6OKsOMpBdT4kXPDDB9cJk2bJ6mh9ucxdlnNvH1e+roYkKmN9Nxw2yjz7VzeO9oOz2zJ04Pw==, tarball: https://registry.npmmirror.com/ws/-/ws-8.18.0.tgz}
133 |     engines: {node: '>=10.0.0'}
134 |     peerDependencies:
135 |       bufferutil: ^4.0.1
136 |       utf-8-validate: '>=5.0.2'
137 |     peerDependenciesMeta:
138 |       bufferutil:
139 |         optional: true
140 |       utf-8-validate:
141 |         optional: true
142 | 
143 | snapshots:
144 | 
145 |   '@adraffy/ens-normalize@1.10.1': {}
146 | 
147 |   '@msgpack/msgpack@3.0.0-beta2': {}
148 | 
149 |   '@noble/curves@1.2.0':
150 |     dependencies:
151 |       '@noble/hashes': 1.3.2
152 | 
153 |   '@noble/hashes@1.3.2': {}
154 | 
155 |   '@types/node@18.15.13': {}
156 | 
157 |   '@types/node@22.5.5':
158 |     dependencies:
159 |       undici-types: 6.19.8
160 | 
161 |   '@types/ws@8.5.12':
162 |     dependencies:
163 |       '@types/node': 22.5.5
164 | 
165 |   aes-js@4.0.0-beta.5: {}
166 | 
167 |   asynckit@0.4.0: {}
168 | 
169 |   axios@1.7.7:
170 |     dependencies:
171 |       follow-redirects: 1.15.9
172 |       form-data: 4.0.0
173 |       proxy-from-env: 1.1.0
174 |     transitivePeerDependencies:
175 |       - debug
176 | 
177 |   combined-stream@1.0.8:
178 |     dependencies:
179 |       delayed-stream: 1.0.0
180 | 
181 |   delayed-stream@1.0.0: {}
182 | 
183 |   dotenv@16.4.5: {}
184 | 
185 |   ethers@6.13.2:
186 |     dependencies:
187 |       '@adraffy/ens-normalize': 1.10.1
188 |       '@noble/curves': 1.2.0
189 |       '@noble/hashes': 1.3.2
190 |       '@types/node': 18.15.13
191 |       aes-js: 4.0.0-beta.5
192 |       tslib: 2.4.0
193 |       ws: 8.17.1
194 |     transitivePeerDependencies:
195 |       - bufferutil
196 |       - utf-8-validate
197 | 
198 |   follow-redirects@1.15.9: {}
199 | 
200 |   form-data@4.0.0:
201 |     dependencies:
202 |       asynckit: 0.4.0
203 |       combined-stream: 1.0.8
204 |       mime-types: 2.1.35
205 | 
206 |   mime-db@1.52.0: {}
207 | 
208 |   mime-types@2.1.35:
209 |     dependencies:
210 |       mime-db: 1.52.0
211 | 
212 |   proxy-from-env@1.1.0: {}
213 | 
214 |   tslib@2.4.0: {}
215 | 
216 |   typescript@5.6.2: {}
217 | 
218 |   undici-types@6.19.8: {}
219 | 
220 |   ws@8.17.1: {}
221 | 
222 |   ws@8.18.0: {}
223 | 


--------------------------------------------------------------------------------
/src/browser.ts:
--------------------------------------------------------------------------------
 1 | // Browser-specific entry point
 2 | import { Hyperliquid } from './index';
 3 | import { environment } from './utils/environment';
 4 | 
 5 | // Ensure we're in a browser environment
 6 | if (!environment.isBrowser) {
 7 |   console.warn('This entry point is intended for browser use only.');
 8 | }
 9 | 
10 | // Re-export main class and types
11 | export { Hyperliquid };
12 | export * from './types';
13 | 
14 | // Add browser-specific utilities
15 | export const utils = {
16 |   isBrowserSupported(): boolean {
17 |     return environment.supportsWebSocket() && environment.supportsCrypto();
18 |   },
19 | 
20 |   isSecureContext(): boolean {
21 |     return window.isSecureContext;
22 |   },
23 | 
24 |   checkCompatibility(): {
25 |     supported: boolean;
26 |     features: {
27 |       webSocket: boolean;
28 |       crypto: boolean;
29 |       secureContext: boolean;
30 |     };
31 |   } {
32 |     const features = {
33 |       webSocket: environment.supportsWebSocket(),
34 |       crypto: environment.supportsCrypto(),
35 |       secureContext: window.isSecureContext,
36 |     };
37 | 
38 |     return {
39 |       supported: features.webSocket && features.crypto,
40 |       features,
41 |     };
42 |   },
43 | };
44 | 


--------------------------------------------------------------------------------
/src/global.d.ts:
--------------------------------------------------------------------------------
 1 | // src/global.d.ts
 2 | 
 3 | // Augment the global scope
 4 | declare global {
 5 |   // Declare AbortSignal to resolve conflicts
 6 |   interface AbortSignalConstructor {
 7 |     new (): AbortSignal;
 8 |     prototype: AbortSignal;
 9 |     abort(reason?: any): AbortSignal;
10 |     timeout(milliseconds: number): AbortSignal;
11 |     any(signals: AbortSignal[]): AbortSignal;
12 |   }
13 | 
14 |   var AbortSignal: AbortSignalConstructor;
15 | }
16 | 
17 | // This file is a module, so we need an export
18 | export {};
19 | 


--------------------------------------------------------------------------------
/src/index.ts:
--------------------------------------------------------------------------------
  1 | import { InfoAPI } from './rest/info';
  2 | import { ExchangeAPI } from './rest/exchange';
  3 | import { WebSocketClient } from './websocket/connection';
  4 | import { WebSocketSubscriptions } from './websocket/subscriptions';
  5 | import { RateLimiter } from './utils/rateLimiter';
  6 | import * as CONSTANTS from './types/constants';
  7 | import { CustomOperations } from './rest/custom';
  8 | import { ethers } from 'ethers';
  9 | import { SymbolConversion } from './utils/symbolConversion';
 10 | import { AuthenticationError } from './utils/errors';
 11 | import { environment } from './utils/environment';
 12 | 
 13 | export interface HyperliquidConfig {
 14 |   enableWs?: boolean;
 15 |   privateKey?: string;
 16 |   testnet?: boolean;
 17 |   walletAddress?: string;
 18 |   vaultAddress?: string;
 19 |   maxReconnectAttempts?: number;
 20 | }
 21 | 
 22 | export class Hyperliquid {
 23 |   public info: InfoAPI;
 24 |   public exchange: ExchangeAPI = {} as ExchangeAPI;
 25 |   public ws: WebSocketClient;
 26 |   public subscriptions: WebSocketSubscriptions;
 27 |   public custom: CustomOperations;
 28 |   public symbolConversion: SymbolConversion;
 29 | 
 30 |   private rateLimiter: RateLimiter;
 31 |   private isValidPrivateKey: boolean = false;
 32 |   private walletAddress: string | null = null;
 33 |   private _initialized: boolean = false;
 34 |   private _initializing: Promise<void> | null = null;
 35 |   private _privateKey?: string;
 36 |   private _walletAddress?: string;
 37 |   private vaultAddress?: string | null = null;
 38 |   private enableWs: boolean;
 39 |   private baseUrl: string;
 40 |   private testnet: boolean;
 41 | 
 42 |   constructor(params: HyperliquidConfig = {}) {
 43 |     const {
 44 |       enableWs = true,
 45 |       privateKey,
 46 |       testnet = false,
 47 |       walletAddress,
 48 |       vaultAddress,
 49 |       maxReconnectAttempts,
 50 |     } = params;
 51 | 
 52 |     // Browser-specific security warnings
 53 |     if (environment.isBrowser) {
 54 |       if (privateKey) {
 55 |         console.warn(
 56 |           'Warning: Storing private keys in browser environments is not recommended. Consider using a Web3 wallet provider instead.'
 57 |         );
 58 |       }
 59 |       if (!window.isSecureContext) {
 60 |         console.warn('Warning: Running in an insecure context. Some features may be limited.');
 61 |       }
 62 |     }
 63 | 
 64 |     this.testnet = testnet;
 65 |     this.baseUrl = testnet ? CONSTANTS.BASE_URLS.TESTNET : CONSTANTS.BASE_URLS.PRODUCTION;
 66 |     this.enableWs = enableWs;
 67 |     this.rateLimiter = new RateLimiter();
 68 |     this.symbolConversion = new SymbolConversion(this.baseUrl, this.rateLimiter);
 69 |     this.walletAddress = walletAddress || null;
 70 |     this.vaultAddress = vaultAddress || null;
 71 | 
 72 |     // Initialize REST API clients
 73 |     this.info = new InfoAPI(this.baseUrl, this.rateLimiter, this.symbolConversion, this);
 74 | 
 75 |     // Initialize custom operations
 76 |     this.custom = new CustomOperations(this);
 77 | 
 78 |     // Initialize WebSocket client if enabled
 79 |     if (enableWs) {
 80 |       if (!environment.hasNativeWebSocket() && environment.isNode) {
 81 |         console.warn(
 82 |           'Native WebSocket support is not available in this Node.js version. Attempting to use ws package...'
 83 |         );
 84 |       }
 85 | 
 86 |       // Create WebSocket client - it will attempt to use ws package if native WebSocket is not available
 87 |       this.ws = new WebSocketClient(testnet, maxReconnectAttempts);
 88 |       this.subscriptions = new WebSocketSubscriptions(this.ws, this.symbolConversion);
 89 | 
 90 |       // Only disable WebSocket if the client fails to initialize
 91 |       if (!environment.supportsWebSocket()) {
 92 |         console.warn(
 93 |           'WebSocket support is not available. Please install the ws package to enable WebSocket features:\n\nnpm install ws\n'
 94 |         );
 95 |         this.enableWs = false;
 96 |       }
 97 |     } else {
 98 |       // Initialize with dummy objects if WebSocket is disabled
 99 |       this.ws = {} as WebSocketClient;
100 |       this.subscriptions = {} as WebSocketSubscriptions;
101 |     }
102 | 
103 |     // Set up authentication if private key is provided
104 |     if (privateKey) {
105 |       this.initializeWithPrivateKey(privateKey, testnet);
106 |     } else if (walletAddress) {
107 |       this._walletAddress = walletAddress;
108 |       this.walletAddress = walletAddress;
109 |     }
110 |   }
111 | 
112 |   public async connect(): Promise<void> {
113 |     if (!this._initialized) {
114 |       if (!this._initializing) {
115 |         this._initializing = this.initialize();
116 |       }
117 |       await this._initializing;
118 |     }
119 |   }
120 | 
121 |   private async initialize(): Promise<void> {
122 |     if (this._initialized) return;
123 | 
124 |     try {
125 |       // Initialize symbol conversion first
126 |       await this.symbolConversion.initialize();
127 | 
128 |       // Connect WebSocket if enabled
129 |       if (this.enableWs) {
130 |         try {
131 |           await this.ws.connect();
132 |         } catch (wsError: unknown) {
133 |           const errorMessage = wsError instanceof Error ? wsError.message : String(wsError);
134 |           console.warn('Failed to establish WebSocket connection:', errorMessage);
135 |           if (errorMessage.includes('Please install the ws package')) {
136 |             console.warn('To enable WebSocket support, please run: npm install ws');
137 |             this.enableWs = false;
138 |           }
139 |           // Don't throw here - we want to continue initialization even if WebSocket fails
140 |         }
141 |       }
142 | 
143 |       this._initialized = true;
144 |       this._initializing = null;
145 |     } catch (error) {
146 |       this._initializing = null;
147 |       throw error;
148 |     }
149 |   }
150 | 
151 |   public async ensureInitialized(): Promise<void> {
152 |     await this.connect();
153 |   }
154 | 
155 |   private initializePrivateKey(privateKey: string, testnet: boolean): void {
156 |     try {
157 |       const formattedPrivateKey = privateKey.startsWith('0x') ? privateKey : `0x${privateKey}`;
158 |       new ethers.Wallet(formattedPrivateKey); // Validate the private key
159 | 
160 |       this.exchange = new ExchangeAPI(
161 |         testnet,
162 |         formattedPrivateKey,
163 |         this.info,
164 |         this.rateLimiter,
165 |         this.symbolConversion,
166 |         this.walletAddress,
167 |         this,
168 |         this.vaultAddress
169 |       );
170 | 
171 |       this.custom = new CustomOperations(
172 |         this.exchange,
173 |         this.info,
174 |         formattedPrivateKey,
175 |         this.symbolConversion,
176 |         this.walletAddress
177 |       );
178 | 
179 |       this.isValidPrivateKey = true;
180 |     } catch (error) {
181 |       console.warn('Invalid private key provided. Some functionalities will be limited.');
182 |       this.isValidPrivateKey = false;
183 |     }
184 |   }
185 | 
186 |   private createAuthenticatedProxy<T extends object>(Class: new (...args: any[]) => T): T {
187 |     return new Proxy({} as T, {
188 |       get: (target, prop) => {
189 |         if (!this.isValidPrivateKey) {
190 |           throw new AuthenticationError(
191 |             'Invalid or missing private key. This method requires authentication.'
192 |           );
193 |         }
194 |         return target[prop as keyof T];
195 |       },
196 |     });
197 |   }
198 | 
199 |   private initializeWithPrivateKey(privateKey: string, testnet: boolean = false): void {
200 |     try {
201 |       const formattedPrivateKey = privateKey.startsWith('0x')
202 |         ? privateKey
203 |         : (`0x${privateKey}` as `0x${string}`);
204 |       new ethers.Wallet(formattedPrivateKey); // Validate the private key
205 | 
206 |       this.exchange = new ExchangeAPI(
207 |         testnet,
208 |         formattedPrivateKey,
209 |         this.info,
210 |         this.rateLimiter,
211 |         this.symbolConversion,
212 |         this.walletAddress,
213 |         this,
214 |         this.vaultAddress
215 |       );
216 |       this.custom = new CustomOperations(
217 |         this.exchange,
218 |         this.info,
219 |         formattedPrivateKey,
220 |         this.symbolConversion,
221 |         this.walletAddress
222 |       );
223 |       this.isValidPrivateKey = true;
224 |     } catch (error) {
225 |       console.warn('Invalid private key provided. Some functionalities will be limited.');
226 |       this.isValidPrivateKey = false;
227 |     }
228 |   }
229 | 
230 |   // Modify existing methods to check initialization
231 |   public isAuthenticated(): boolean {
232 |     this.ensureInitialized();
233 |     return this.isValidPrivateKey;
234 |   }
235 | 
236 |   public isWebSocketConnected(): boolean {
237 |     return this.ws?.isConnected() ?? false;
238 |   }
239 | 
240 |   disconnect(): void {
241 |     // Stop the asset map refresh interval
242 |     this.symbolConversion.stopPeriodicRefresh();
243 | 
244 |     // Close WebSocket connection if enabled
245 |     if (this.enableWs && this.ws && typeof this.ws.close === 'function') {
246 |       this.ws.close(true); // Pass true to indicate manual disconnect
247 |     }
248 | 
249 |     // Reset initialization state
250 |     this._initialized = false;
251 |     this._initializing = null;
252 |   }
253 | 
254 |   public getBaseUrl(): string {
255 |     return this.baseUrl;
256 |   }
257 | 
258 |   public getRateLimiter(): RateLimiter {
259 |     return this.rateLimiter;
260 |   }
261 | }
262 | 
263 | export * from './types';
264 | export * from './utils/signing';
265 | 


--------------------------------------------------------------------------------
/src/rest/custom.ts:
--------------------------------------------------------------------------------
  1 | // src/rest/custom.ts
  2 | 
  3 | import { ethers } from 'ethers';
  4 | import { InfoAPI } from './info';
  5 | import { ExchangeAPI } from './exchange';
  6 | import { UserOpenOrders } from '../types';
  7 | import { OrderResponse, CancelOrderRequest, OrderRequest, OrderType } from '../types/index';
  8 | import { CancelOrderResponse } from '../utils/signing';
  9 | import { SymbolConversion } from '../utils/symbolConversion';
 10 | import { floatToWire } from '../utils/signing';
 11 | import { Hyperliquid } from '../index';
 12 | 
 13 | export class CustomOperations {
 14 |   private exchange: ExchangeAPI;
 15 |   private infoApi: InfoAPI;
 16 |   private wallet?: ethers.Wallet;
 17 |   private symbolConversion: SymbolConversion;
 18 |   private walletAddress: string | null;
 19 |   private parent?: Hyperliquid;
 20 | 
 21 |   constructor(
 22 |     exchangeOrParent: ExchangeAPI | Hyperliquid,
 23 |     infoApiOrPrivateKey?: InfoAPI | string,
 24 |     privateKeyOrSymbolConversion?: string | SymbolConversion,
 25 |     symbolConversionOrWalletAddress?: SymbolConversion | string | null,
 26 |     walletAddress?: string | null
 27 |   ) {
 28 |     // Check if first argument is Hyperliquid instance
 29 |     if (exchangeOrParent instanceof Hyperliquid) {
 30 |       this.parent = exchangeOrParent;
 31 |       this.exchange = exchangeOrParent.exchange;
 32 |       this.infoApi = exchangeOrParent.info;
 33 |       this.symbolConversion = exchangeOrParent.symbolConversion;
 34 |       this.walletAddress = exchangeOrParent.isAuthenticated()
 35 |         ? exchangeOrParent.isAuthenticated().toString()
 36 |         : null;
 37 |     } else {
 38 |       // Original constructor
 39 |       this.exchange = exchangeOrParent;
 40 |       this.infoApi = infoApiOrPrivateKey as InfoAPI;
 41 |       if (privateKeyOrSymbolConversion && typeof privateKeyOrSymbolConversion === 'string') {
 42 |         this.wallet = new ethers.Wallet(privateKeyOrSymbolConversion);
 43 |       }
 44 |       this.symbolConversion = symbolConversionOrWalletAddress as SymbolConversion;
 45 |       this.walletAddress = walletAddress || null;
 46 |     }
 47 |   }
 48 | 
 49 |   private getUserAddress(): string {
 50 |     if (!this.walletAddress && !this.wallet?.address) {
 51 |       throw new Error(
 52 |         'No wallet address available. Please provide a wallet address or private key.'
 53 |       );
 54 |     }
 55 |     return this.walletAddress || this.wallet!.address;
 56 |   }
 57 | 
 58 |   async cancelAllOrders(symbol?: string): Promise<CancelOrderResponse> {
 59 |     try {
 60 |       const address = this.getUserAddress();
 61 |       const openOrders: UserOpenOrders = await this.infoApi.getUserOpenOrders(address);
 62 | 
 63 |       let ordersToCancel: UserOpenOrders;
 64 | 
 65 |       for (let order of openOrders) {
 66 |         order.coin = await this.symbolConversion.convertSymbol(order.coin);
 67 |       }
 68 | 
 69 |       if (symbol) {
 70 |         ordersToCancel = openOrders.filter(order => order.coin === symbol);
 71 |       } else {
 72 |         ordersToCancel = openOrders;
 73 |       }
 74 | 
 75 |       if (ordersToCancel.length === 0) {
 76 |         throw new Error('No orders to cancel');
 77 |       }
 78 | 
 79 |       const cancelRequests: CancelOrderRequest[] = ordersToCancel.map(order => ({
 80 |         coin: order.coin,
 81 |         o: order.oid,
 82 |       }));
 83 | 
 84 |       const response = await this.exchange.cancelOrder(cancelRequests);
 85 |       return response;
 86 |     } catch (error) {
 87 |       throw error;
 88 |     }
 89 |   }
 90 | 
 91 |   async getAllAssets(): Promise<{ perp: string[]; spot: string[] }> {
 92 |     return await this.symbolConversion.getAllAssets();
 93 |   }
 94 | 
 95 |   private DEFAULT_SLIPPAGE = 0.05;
 96 | 
 97 |   private async getSlippagePrice(
 98 |     symbol: string,
 99 |     isBuy: boolean,
100 |     slippage: number,
101 |     px?: number
102 |   ): Promise<number> {
103 |     const convertedSymbol = await this.symbolConversion.convertSymbol(symbol);
104 |     if (!px) {
105 |       const allMids = await this.infoApi.getAllMids();
106 |       px = Number(allMids[convertedSymbol]);
107 |     }
108 | 
109 |     const isSpot = symbol.includes('-SPOT');
110 | 
111 |     //If not isSpot count how many decimals price has to use the same amount for rounding
112 |     const decimals = px.toString().split('.')[1]?.length || 0;
113 | 
114 |     console.log(decimals);
115 | 
116 |     px *= isBuy ? 1 + slippage : 1 - slippage;
117 |     return Number(px.toFixed(isSpot ? 8 : Math.max(0, decimals - 1)));
118 |   }
119 | 
120 |   async marketOpen(
121 |     symbol: string,
122 |     isBuy: boolean,
123 |     size: number,
124 |     px?: number,
125 |     slippage: number = this.DEFAULT_SLIPPAGE,
126 |     cloid?: string
127 |   ): Promise<OrderResponse> {
128 |     const convertedSymbol = await this.symbolConversion.convertSymbol(symbol);
129 |     const slippagePrice = await this.getSlippagePrice(convertedSymbol, isBuy, slippage, px);
130 |     console.log('Slippage Price: ', slippagePrice);
131 | 
132 |     const orderRequest: OrderRequest = {
133 |       coin: convertedSymbol,
134 |       is_buy: isBuy,
135 |       sz: size,
136 |       limit_px: slippagePrice,
137 |       order_type: { limit: { tif: 'Ioc' } } as OrderType,
138 |       reduce_only: false,
139 |     };
140 | 
141 |     if (cloid) {
142 |       orderRequest.cloid = cloid;
143 |     }
144 |     console.log(orderRequest);
145 |     return this.exchange.placeOrder(orderRequest);
146 |   }
147 | 
148 |   async marketClose(
149 |     symbol: string,
150 |     size?: number,
151 |     px?: number,
152 |     slippage: number = this.DEFAULT_SLIPPAGE,
153 |     cloid?: string
154 |   ): Promise<OrderResponse> {
155 |     const convertedSymbol = await this.symbolConversion.convertSymbol(symbol);
156 |     const address = this.getUserAddress();
157 |     const positions = await this.infoApi.perpetuals.getClearinghouseState(address);
158 |     for (const position of positions.assetPositions) {
159 |       const item = position.position;
160 |       if (convertedSymbol !== item.coin) {
161 |         continue;
162 |       }
163 |       const szi = parseFloat(item.szi);
164 |       const closeSize = size || Math.abs(szi);
165 |       const isBuy = szi < 0;
166 | 
167 |       // Get aggressive Market Price
168 |       const slippagePrice = await this.getSlippagePrice(convertedSymbol, isBuy, slippage, px);
169 | 
170 |       // Market Order is an aggressive Limit Order IoC
171 |       const orderRequest: OrderRequest = {
172 |         coin: convertedSymbol,
173 |         is_buy: isBuy,
174 |         sz: closeSize,
175 |         limit_px: slippagePrice,
176 |         order_type: { limit: { tif: 'Ioc' } } as OrderType,
177 |         reduce_only: true,
178 |       };
179 | 
180 |       if (cloid) {
181 |         orderRequest.cloid = cloid;
182 |       }
183 | 
184 |       return this.exchange.placeOrder(orderRequest);
185 |     }
186 | 
187 |     throw new Error(`No position found for ${convertedSymbol}`);
188 |   }
189 | 
190 |   async closeAllPositions(slippage: number = this.DEFAULT_SLIPPAGE): Promise<OrderResponse[]> {
191 |     try {
192 |       const address = this.getUserAddress();
193 |       const positions = await this.infoApi.perpetuals.getClearinghouseState(address);
194 |       const closeOrders: Promise<OrderResponse>[] = [];
195 | 
196 |       console.log(positions);
197 | 
198 |       for (const position of positions.assetPositions) {
199 |         const item = position.position;
200 |         if (parseFloat(item.szi) !== 0) {
201 |           const symbol = await this.symbolConversion.convertSymbol(item.coin, 'forward');
202 |           closeOrders.push(this.marketClose(symbol, undefined, undefined, slippage));
203 |         }
204 |       }
205 | 
206 |       return await Promise.all(closeOrders);
207 |     } catch (error) {
208 |       throw error;
209 |     }
210 |   }
211 | }
212 | 


--------------------------------------------------------------------------------
/src/rest/exchange.ts:
--------------------------------------------------------------------------------
   1 | import { ethers } from 'ethers';
   2 | import { RateLimiter } from '../utils/rateLimiter';
   3 | import { HttpApi } from '../utils/helpers';
   4 | import { InfoAPI } from './info';
   5 | import {
   6 |   signL1Action,
   7 |   orderToWire,
   8 |   orderWireToAction,
   9 |   CancelOrderResponse,
  10 |   signUserSignedAction,
  11 |   signUsdTransferAction,
  12 |   signWithdrawFromBridgeAction,
  13 |   signAgent,
  14 |   removeTrailingZeros,
  15 | } from '../utils/signing';
  16 | import * as CONSTANTS from '../types/constants';
  17 | 
  18 | import {
  19 |   Builder,
  20 |   CancelOrderRequest,
  21 |   Grouping,
  22 |   Order,
  23 |   OrderRequest,
  24 |   MultiOrder,
  25 |   BulkOrderRequest,
  26 |   TwapCancelRequest,
  27 |   TwapCancelResponse,
  28 |   TwapOrder,
  29 |   TwapOrderResponse,
  30 |   ApproveAgentRequest,
  31 |   ApproveBuilderFeeRequest,
  32 |   CreateVaultRequest,
  33 |   CreateVaultResponse,
  34 |   VaultDistributeRequest,
  35 |   VaultModifyRequest,
  36 |   CreateSubAccountResponse,
  37 |   ClaimRewardsResponse,
  38 |   SetDisplayNameResponse,
  39 |   SpotUserResponse,
  40 |   CDepositResponse,
  41 |   CWithdrawResponse,
  42 |   TokenDelegateResponse,
  43 |   SubAccountSpotTransferResponse,
  44 |   SubAccountTransferResponse,
  45 |   ReserveRequestWeightRequest,
  46 |   ReserveRequestWeightResponse,
  47 | } from '../types/index';
  48 | 
  49 | import { ExchangeType, ENDPOINTS, CHAIN_IDS } from '../types/constants';
  50 | import { SymbolConversion } from '../utils/symbolConversion';
  51 | import { Hyperliquid } from '../index';
  52 | 
  53 | // const IS_MAINNET = true; // Make sure this matches the IS_MAINNET in signing.ts
  54 | 
  55 | export class ExchangeAPI {
  56 |   private wallet: ethers.Wallet;
  57 |   private httpApi: HttpApi;
  58 |   private symbolConversion: SymbolConversion;
  59 |   private IS_MAINNET = true;
  60 |   private walletAddress: string | null;
  61 |   private _i = 0;
  62 |   private parent: Hyperliquid;
  63 |   private vaultAddress: string | null;
  64 |   // Properties for unique nonce generation
  65 |   private nonceCounter = 0;
  66 |   private lastNonceTimestamp = 0;
  67 | 
  68 |   constructor(
  69 |     testnet: boolean,
  70 |     privateKey: string,
  71 |     private info: InfoAPI,
  72 |     rateLimiter: RateLimiter,
  73 |     symbolConversion: SymbolConversion,
  74 |     walletAddress: string | null = null,
  75 |     parent: Hyperliquid,
  76 |     vaultAddress: string | null = null
  77 |   ) {
  78 |     const baseURL = testnet ? CONSTANTS.BASE_URLS.TESTNET : CONSTANTS.BASE_URLS.PRODUCTION;
  79 |     this.IS_MAINNET = !testnet;
  80 |     this.httpApi = new HttpApi(baseURL, ENDPOINTS.EXCHANGE, rateLimiter);
  81 |     this.wallet = new ethers.Wallet(privateKey);
  82 |     this.symbolConversion = symbolConversion;
  83 |     this.walletAddress = walletAddress;
  84 |     this.parent = parent;
  85 |     this.vaultAddress = vaultAddress;
  86 |   }
  87 | 
  88 |   private getVaultAddress(): string | null {
  89 |     return this.vaultAddress;
  90 |   }
  91 | 
  92 |   private async getAssetIndex(symbol: string): Promise<number> {
  93 |     const index = await this.symbolConversion.getAssetIndex(symbol);
  94 |     if (index === undefined) {
  95 |       throw new Error(`Unknown asset: ${symbol}`);
  96 |     }
  97 |     if (!this._i) {
  98 |       this._i = 1;
  99 |       setTimeout(() => {
 100 |         try {
 101 |           this.setReferrer();
 102 |         } catch {}
 103 |       });
 104 |     }
 105 |     return index;
 106 |   }
 107 | 
 108 |   async placeOrder(orderRequest: OrderRequest | Order | BulkOrderRequest): Promise<any> {
 109 |     await this.parent.ensureInitialized();
 110 |     const vaultAddress = this.getVaultAddress();
 111 |     const grouping = (orderRequest as any).grouping || 'na';
 112 |     let builder = (orderRequest as any).builder;
 113 | 
 114 |     // Normalize builder address to lowercase if it exists
 115 |     if (builder) {
 116 |       builder = {
 117 |         ...builder,
 118 |         address: builder.address?.toLowerCase() || builder.b?.toLowerCase(),
 119 |       };
 120 |     }
 121 | 
 122 |     // Determine if this is a bulk order request (has 'orders' array)
 123 |     const isBulkOrder = 'orders' in orderRequest && Array.isArray(orderRequest.orders);
 124 |     const ordersArray = isBulkOrder
 125 |       ? (orderRequest as BulkOrderRequest).orders
 126 |       : [orderRequest as OrderRequest];
 127 | 
 128 |     try {
 129 |       const assetIndexCache = new Map<string, number>();
 130 | 
 131 |       // Normalize price and size values to remove trailing zeros
 132 |       const normalizedOrders = ordersArray.map((order: OrderRequest) => {
 133 |         const normalizedOrder = { ...order };
 134 | 
 135 |         // Handle price normalization
 136 |         if (typeof normalizedOrder.limit_px === 'string') {
 137 |           normalizedOrder.limit_px = removeTrailingZeros(normalizedOrder.limit_px);
 138 |         }
 139 | 
 140 |         // Handle size normalization
 141 |         if (typeof normalizedOrder.sz === 'string') {
 142 |           normalizedOrder.sz = removeTrailingZeros(normalizedOrder.sz);
 143 |         }
 144 | 
 145 |         return normalizedOrder;
 146 |       });
 147 | 
 148 |       const orderWires = await Promise.all(
 149 |         normalizedOrders.map(async (o: OrderRequest) => {
 150 |           let assetIndex = assetIndexCache.get(o.coin);
 151 |           if (assetIndex === undefined) {
 152 |             assetIndex = await this.getAssetIndex(o.coin);
 153 |             assetIndexCache.set(o.coin, assetIndex);
 154 |           }
 155 |           return orderToWire(o, assetIndex);
 156 |         })
 157 |       );
 158 | 
 159 |       const actions = orderWireToAction(orderWires, grouping, builder);
 160 | 
 161 |       const nonce = this.generateUniqueNonce();
 162 |       const signature = await signL1Action(
 163 |         this.wallet,
 164 |         actions,
 165 |         vaultAddress,
 166 |         nonce,
 167 |         this.IS_MAINNET
 168 |       );
 169 | 
 170 |       const payload = { action: actions, nonce, signature, vaultAddress };
 171 |       return this.httpApi.makeRequest(payload, 1);
 172 |     } catch (error) {
 173 |       throw error;
 174 |     }
 175 |   }
 176 | 
 177 |   async cancelOrder(
 178 |     cancelRequests: CancelOrderRequest | CancelOrderRequest[]
 179 |   ): Promise<CancelOrderResponse> {
 180 |     await this.parent.ensureInitialized();
 181 |     try {
 182 |       const cancels = Array.isArray(cancelRequests) ? cancelRequests : [cancelRequests];
 183 |       const vaultAddress = this.getVaultAddress();
 184 | 
 185 |       const cancelsWithIndices = await Promise.all(
 186 |         cancels.map(async req => ({
 187 |           ...req,
 188 |           a: await this.getAssetIndex(req.coin),
 189 |         }))
 190 |       );
 191 | 
 192 |       const action = {
 193 |         type: ExchangeType.CANCEL,
 194 |         cancels: cancelsWithIndices.map(({ a, o }) => ({ a, o })),
 195 |       };
 196 | 
 197 |       const nonce = this.generateUniqueNonce();
 198 |       const signature = await signL1Action(
 199 |         this.wallet,
 200 |         action,
 201 |         vaultAddress,
 202 |         nonce,
 203 |         this.IS_MAINNET
 204 |       );
 205 | 
 206 |       const payload = { action, nonce, signature, vaultAddress };
 207 |       return this.httpApi.makeRequest(payload, 1);
 208 |     } catch (error) {
 209 |       throw error;
 210 |     }
 211 |   }
 212 | 
 213 |   //Cancel using a CLOID
 214 |   async cancelOrderByCloid(symbol: string, cloid: string): Promise<any> {
 215 |     await this.parent.ensureInitialized();
 216 |     try {
 217 |       const assetIndex = await this.getAssetIndex(symbol);
 218 |       const vaultAddress = this.getVaultAddress();
 219 |       const action = {
 220 |         type: ExchangeType.CANCEL_BY_CLOID,
 221 |         cancels: [{ asset: assetIndex, cloid }],
 222 |       };
 223 |       const nonce = this.generateUniqueNonce();
 224 |       const signature = await signL1Action(
 225 |         this.wallet,
 226 |         action,
 227 |         vaultAddress,
 228 |         nonce,
 229 |         this.IS_MAINNET
 230 |       );
 231 | 
 232 |       const payload = { action, nonce, signature, vaultAddress };
 233 |       return this.httpApi.makeRequest(payload, 1);
 234 |     } catch (error) {
 235 |       throw error;
 236 |     }
 237 |   }
 238 | 
 239 |   //Modify a single order
 240 |   async modifyOrder(oid: number | string, orderRequest: Order): Promise<any> {
 241 |     await this.parent.ensureInitialized();
 242 |     try {
 243 |       const assetIndex = await this.getAssetIndex(orderRequest.coin);
 244 |       const vaultAddress = this.getVaultAddress();
 245 | 
 246 |       // Normalize price and size values to remove trailing zeros
 247 |       const normalizedOrder = { ...orderRequest };
 248 | 
 249 |       // Handle price normalization
 250 |       if (typeof normalizedOrder.limit_px === 'string') {
 251 |         normalizedOrder.limit_px = removeTrailingZeros(normalizedOrder.limit_px);
 252 |       }
 253 | 
 254 |       // Handle size normalization
 255 |       if (typeof normalizedOrder.sz === 'string') {
 256 |         normalizedOrder.sz = removeTrailingZeros(normalizedOrder.sz);
 257 |       }
 258 | 
 259 |       const orderWire = orderToWire(normalizedOrder, assetIndex);
 260 |       const action = {
 261 |         type: ExchangeType.MODIFY,
 262 |         oid,
 263 |         order: orderWire,
 264 |       };
 265 |       const nonce = this.generateUniqueNonce();
 266 |       const signature = await signL1Action(
 267 |         this.wallet,
 268 |         action,
 269 |         vaultAddress,
 270 |         nonce,
 271 |         this.IS_MAINNET
 272 |       );
 273 | 
 274 |       const payload = { action, nonce, signature, vaultAddress };
 275 |       return this.httpApi.makeRequest(payload, 1);
 276 |     } catch (error) {
 277 |       throw error;
 278 |     }
 279 |   }
 280 | 
 281 |   //Modify multiple orders at once
 282 |   async batchModifyOrders(modifies: Array<{ oid: number | string; order: Order }>): Promise<any> {
 283 |     await this.parent.ensureInitialized();
 284 |     try {
 285 |       const vaultAddress = this.getVaultAddress();
 286 |       const assetIndices = await Promise.all(modifies.map(m => this.getAssetIndex(m.order.coin)));
 287 | 
 288 |       // Normalize price and size values to remove trailing zeros
 289 |       const normalizedModifies = modifies.map(m => {
 290 |         const normalizedOrder = { ...m.order };
 291 | 
 292 |         // Handle price normalization
 293 |         if (typeof normalizedOrder.limit_px === 'string') {
 294 |           normalizedOrder.limit_px = removeTrailingZeros(normalizedOrder.limit_px);
 295 |         }
 296 | 
 297 |         // Handle size normalization
 298 |         if (typeof normalizedOrder.sz === 'string') {
 299 |           normalizedOrder.sz = removeTrailingZeros(normalizedOrder.sz);
 300 |         }
 301 | 
 302 |         return { oid: m.oid, order: normalizedOrder };
 303 |       });
 304 | 
 305 |       const action = {
 306 |         type: ExchangeType.BATCH_MODIFY,
 307 |         modifies: normalizedModifies.map((m, index) => ({
 308 |           oid: m.oid,
 309 |           order: orderToWire(m.order, assetIndices[index]),
 310 |         })),
 311 |       };
 312 | 
 313 |       const nonce = this.generateUniqueNonce();
 314 |       const signature = await signL1Action(
 315 |         this.wallet,
 316 |         action,
 317 |         vaultAddress,
 318 |         nonce,
 319 |         this.IS_MAINNET
 320 |       );
 321 | 
 322 |       const payload = { action, nonce, signature, vaultAddress };
 323 |       return this.httpApi.makeRequest(payload, 1);
 324 |     } catch (error) {
 325 |       throw error;
 326 |     }
 327 |   }
 328 | 
 329 |   //Update leverage. Set leverageMode to "cross" if you want cross leverage, otherwise it'll set it to "isolated by default"
 330 |   async updateLeverage(symbol: string, leverageMode: string, leverage: number): Promise<any> {
 331 |     await this.parent.ensureInitialized();
 332 |     try {
 333 |       const assetIndex = await this.getAssetIndex(symbol);
 334 |       const vaultAddress = this.getVaultAddress();
 335 |       const action = {
 336 |         type: ExchangeType.UPDATE_LEVERAGE,
 337 |         asset: assetIndex,
 338 |         isCross: leverageMode === 'cross',
 339 |         leverage: leverage,
 340 |       };
 341 |       const nonce = this.generateUniqueNonce();
 342 |       const signature = await signL1Action(
 343 |         this.wallet,
 344 |         action,
 345 |         vaultAddress,
 346 |         nonce,
 347 |         this.IS_MAINNET
 348 |       );
 349 | 
 350 |       const payload = { action, nonce, signature, vaultAddress };
 351 |       return this.httpApi.makeRequest(payload, 1);
 352 |     } catch (error) {
 353 |       throw error;
 354 |     }
 355 |   }
 356 | 
 357 |   //Update how much margin there is on a perps position
 358 |   async updateIsolatedMargin(symbol: string, isBuy: boolean, ntli: number): Promise<any> {
 359 |     await this.parent.ensureInitialized();
 360 |     try {
 361 |       const assetIndex = await this.getAssetIndex(symbol);
 362 |       const vaultAddress = this.getVaultAddress();
 363 |       const action = {
 364 |         type: ExchangeType.UPDATE_ISOLATED_MARGIN,
 365 |         asset: assetIndex,
 366 |         isBuy,
 367 |         ntli,
 368 |       };
 369 |       const nonce = this.generateUniqueNonce();
 370 |       const signature = await signL1Action(
 371 |         this.wallet,
 372 |         action,
 373 |         vaultAddress,
 374 |         nonce,
 375 |         this.IS_MAINNET
 376 |       );
 377 | 
 378 |       const payload = { action, nonce, signature, vaultAddress };
 379 |       return this.httpApi.makeRequest(payload, 1);
 380 |     } catch (error) {
 381 |       throw error;
 382 |     }
 383 |   }
 384 | 
 385 |   //Takes from the perps wallet and sends to another wallet without the $1 fee (doesn't touch bridge, so no fees)
 386 |   async usdTransfer(destination: string, amount: number): Promise<any> {
 387 |     await this.parent.ensureInitialized();
 388 |     try {
 389 |       const action = {
 390 |         type: ExchangeType.USD_SEND,
 391 |         hyperliquidChain: this.IS_MAINNET ? 'Mainnet' : 'Testnet',
 392 |         signatureChainId: this.IS_MAINNET ? CHAIN_IDS.ARBITRUM_MAINNET : CHAIN_IDS.ARBITRUM_TESTNET,
 393 |         destination: destination,
 394 |         amount: amount.toString(),
 395 |         time: Date.now(),
 396 |       };
 397 |       const signature = await signUsdTransferAction(this.wallet, action, this.IS_MAINNET);
 398 | 
 399 |       const payload = { action, nonce: action.time, signature };
 400 |       return this.httpApi.makeRequest(payload, 1); // Remove the third parameter
 401 |     } catch (error) {
 402 |       throw error;
 403 |     }
 404 |   }
 405 |   //Transfer SPOT assets i.e PURR to another wallet (doesn't touch bridge, so no fees)
 406 |   async spotTransfer(destination: string, token: string, amount: string): Promise<any> {
 407 |     await this.parent.ensureInitialized();
 408 |     try {
 409 |       const action = {
 410 |         type: ExchangeType.SPOT_SEND,
 411 |         hyperliquidChain: this.IS_MAINNET ? 'Mainnet' : 'Testnet',
 412 |         signatureChainId: this.IS_MAINNET ? CHAIN_IDS.ARBITRUM_MAINNET : CHAIN_IDS.ARBITRUM_TESTNET,
 413 |         destination,
 414 |         token,
 415 |         amount,
 416 |         time: Date.now(),
 417 |       };
 418 |       const signature = await signUserSignedAction(
 419 |         this.wallet,
 420 |         action,
 421 |         [
 422 |           { name: 'hyperliquidChain', type: 'string' },
 423 |           { name: 'destination', type: 'string' },
 424 |           { name: 'token', type: 'string' },
 425 |           { name: 'amount', type: 'string' },
 426 |           { name: 'time', type: 'uint64' },
 427 |         ],
 428 |         'HyperliquidTransaction:SpotSend',
 429 |         this.IS_MAINNET
 430 |       );
 431 | 
 432 |       const payload = { action, nonce: action.time, signature };
 433 |       return this.httpApi.makeRequest(payload, 1);
 434 |     } catch (error) {
 435 |       throw error;
 436 |     }
 437 |   }
 438 | 
 439 |   //Withdraw USDC, this txn goes across the bridge and costs $1 in fees as of writing this
 440 |   async initiateWithdrawal(destination: string, amount: number): Promise<any> {
 441 |     await this.parent.ensureInitialized();
 442 |     try {
 443 |       const action = {
 444 |         type: ExchangeType.WITHDRAW,
 445 |         hyperliquidChain: this.IS_MAINNET ? 'Mainnet' : 'Testnet',
 446 |         signatureChainId: this.IS_MAINNET ? CHAIN_IDS.ARBITRUM_MAINNET : CHAIN_IDS.ARBITRUM_TESTNET,
 447 |         destination: destination,
 448 |         amount: amount.toString(),
 449 |         time: Date.now(),
 450 |       };
 451 |       const signature = await signWithdrawFromBridgeAction(this.wallet, action, this.IS_MAINNET);
 452 | 
 453 |       const payload = { action, nonce: action.time, signature };
 454 |       return this.httpApi.makeRequest(payload, 1);
 455 |     } catch (error) {
 456 |       throw error;
 457 |     }
 458 |   }
 459 | 
 460 |   /**
 461 |    * Generate a payload for placing an order that can be used with WebSocket POST requests
 462 |    * @param orderRequest Order parameters
 463 |    * @returns A signed payload that can be used with WebSocket POST requests
 464 |    */
 465 |   async getOrderPayload(orderRequest: OrderRequest | Order | BulkOrderRequest): Promise<any> {
 466 |     await this.parent.ensureInitialized();
 467 |     const vaultAddress = this.getVaultAddress();
 468 |     const grouping = (orderRequest as any).grouping || 'na';
 469 |     let builder = (orderRequest as any).builder;
 470 | 
 471 |     // Normalize builder address to lowercase if it exists
 472 |     if (builder) {
 473 |       builder = {
 474 |         ...builder,
 475 |         address: builder.address?.toLowerCase() || builder.b?.toLowerCase(),
 476 |       };
 477 |     }
 478 | 
 479 |     // Determine if this is a bulk order request (has 'orders' array)
 480 |     const isBulkOrder = 'orders' in orderRequest && Array.isArray(orderRequest.orders);
 481 |     const ordersArray = isBulkOrder
 482 |       ? (orderRequest as BulkOrderRequest).orders
 483 |       : [orderRequest as OrderRequest];
 484 | 
 485 |     try {
 486 |       // Cache asset indices to avoid redundant lookups
 487 |       const assetIndexCache = new Map<string, number>();
 488 | 
 489 |       // Normalize orders to ensure consistent format
 490 |       const normalizedOrders = ordersArray.map((order: OrderRequest) => {
 491 |         const normalizedOrder = { ...order };
 492 | 
 493 |         // Handle price normalization
 494 |         if (typeof normalizedOrder.limit_px === 'string') {
 495 |           normalizedOrder.limit_px = removeTrailingZeros(normalizedOrder.limit_px);
 496 |         }
 497 | 
 498 |         // Handle size normalization
 499 |         if (typeof normalizedOrder.sz === 'string') {
 500 |           normalizedOrder.sz = removeTrailingZeros(normalizedOrder.sz);
 501 |         }
 502 | 
 503 |         return normalizedOrder;
 504 |       });
 505 | 
 506 |       const orderWires = await Promise.all(
 507 |         normalizedOrders.map(async (o: OrderRequest) => {
 508 |           let assetIndex = assetIndexCache.get(o.coin);
 509 |           if (assetIndex === undefined) {
 510 |             assetIndex = await this.getAssetIndex(o.coin);
 511 |             assetIndexCache.set(o.coin, assetIndex);
 512 |           }
 513 |           return orderToWire(o, assetIndex);
 514 |         })
 515 |       );
 516 | 
 517 |       const actions = orderWireToAction(orderWires, grouping, builder);
 518 | 
 519 |       const nonce = this.generateUniqueNonce();
 520 |       const signature = await signL1Action(
 521 |         this.wallet,
 522 |         actions,
 523 |         vaultAddress,
 524 |         nonce,
 525 |         this.IS_MAINNET
 526 |       );
 527 | 
 528 |       return { action: actions, nonce, signature, vaultAddress };
 529 |     } catch (error) {
 530 |       throw error;
 531 |     }
 532 |   }
 533 | 
 534 |   /**
 535 |    * Generate a payload for canceling an order that can be used with WebSocket POST requests
 536 |    * @param cancelRequests Cancel order parameters
 537 |    * @returns A signed payload that can be used with WebSocket POST requests
 538 |    */
 539 |   async getCancelOrderPayload(
 540 |     cancelRequests: CancelOrderRequest | CancelOrderRequest[]
 541 |   ): Promise<any> {
 542 |     await this.parent.ensureInitialized();
 543 |     try {
 544 |       const cancels = Array.isArray(cancelRequests) ? cancelRequests : [cancelRequests];
 545 |       const vaultAddress = this.getVaultAddress();
 546 | 
 547 |       const cancelsWithIndices = await Promise.all(
 548 |         cancels.map(async req => ({
 549 |           ...req,
 550 |           a: await this.getAssetIndex(req.coin),
 551 |         }))
 552 |       );
 553 | 
 554 |       const action = {
 555 |         type: ExchangeType.CANCEL,
 556 |         cancels: cancelsWithIndices.map(({ a, o }) => ({ a, o })),
 557 |       };
 558 | 
 559 |       const nonce = this.generateUniqueNonce();
 560 |       const signature = await signL1Action(
 561 |         this.wallet,
 562 |         action,
 563 |         vaultAddress,
 564 |         nonce,
 565 |         this.IS_MAINNET
 566 |       );
 567 | 
 568 |       return { action, nonce, signature, vaultAddress };
 569 |     } catch (error) {
 570 |       throw error;
 571 |     }
 572 |   }
 573 | 
 574 |   /**
 575 |    * Generate a payload for canceling all orders that can be used with WebSocket POST requests
 576 |    * @returns A signed payload that can be used with WebSocket POST requests
 577 |    */
 578 |   async getCancelAllPayload(): Promise<any> {
 579 |     await this.parent.ensureInitialized();
 580 |     try {
 581 |       const vaultAddress = this.getVaultAddress();
 582 |       const action = {
 583 |         type: 'cancelAll',
 584 |       };
 585 |       const nonce = this.generateUniqueNonce();
 586 |       const signature = await signL1Action(
 587 |         this.wallet,
 588 |         action,
 589 |         vaultAddress,
 590 |         nonce,
 591 |         this.IS_MAINNET
 592 |       );
 593 | 
 594 |       return { action, nonce, signature, vaultAddress };
 595 |     } catch (error) {
 596 |       throw error;
 597 |     }
 598 |   }
 599 | 
 600 |   //Transfer between spot and perpetual wallets (intra-account transfer)
 601 |   async transferBetweenSpotAndPerp(usdc: number, toPerp: boolean): Promise<any> {
 602 |     await this.parent.ensureInitialized();
 603 |     try {
 604 |       const nonce = this.generateUniqueNonce();
 605 |       const action = {
 606 |         type: ExchangeType.USD_CLASS_TRANSFER,
 607 |         hyperliquidChain: this.IS_MAINNET ? 'Mainnet' : 'Testnet',
 608 |         signatureChainId: this.IS_MAINNET ? CHAIN_IDS.ARBITRUM_MAINNET : CHAIN_IDS.ARBITRUM_TESTNET,
 609 |         amount: usdc.toString(), // API expects string
 610 |         toPerp: toPerp,
 611 |         nonce: nonce,
 612 |       };
 613 | 
 614 |       const signature = await signUserSignedAction(
 615 |         this.wallet,
 616 |         action,
 617 |         [
 618 |           { name: 'hyperliquidChain', type: 'string' },
 619 |           { name: 'amount', type: 'string' },
 620 |           { name: 'toPerp', type: 'bool' },
 621 |           { name: 'nonce', type: 'uint64' },
 622 |         ],
 623 |         'HyperliquidTransaction:UsdClassTransfer',
 624 |         this.IS_MAINNET
 625 |       );
 626 | 
 627 |       const payload = { action, nonce: action.nonce, signature };
 628 |       return this.httpApi.makeRequest(payload, 1);
 629 |     } catch (error) {
 630 |       throw error;
 631 |     }
 632 |   }
 633 | 
 634 |   //Schedule a cancel for a given time (in ms) //Note: Only available once you've traded $1 000 000 in volume
 635 |   async scheduleCancel(time: number | null): Promise<any> {
 636 |     await this.parent.ensureInitialized();
 637 |     try {
 638 |       const action = { type: ExchangeType.SCHEDULE_CANCEL, time };
 639 |       const nonce = this.generateUniqueNonce();
 640 |       const signature = await signL1Action(this.wallet, action, null, nonce, this.IS_MAINNET);
 641 | 
 642 |       const payload = { action, nonce, signature };
 643 |       return this.httpApi.makeRequest(payload, 1);
 644 |     } catch (error) {
 645 |       throw error;
 646 |     }
 647 |   }
 648 | 
 649 |   //Transfer between vault and perpetual wallets (intra-account transfer)
 650 |   async vaultTransfer(vaultAddress: string, isDeposit: boolean, usd: number): Promise<any> {
 651 |     await this.parent.ensureInitialized();
 652 |     try {
 653 |       const action = {
 654 |         type: ExchangeType.VAULT_TRANSFER,
 655 |         vaultAddress,
 656 |         isDeposit,
 657 |         usd,
 658 |       };
 659 |       const nonce = this.generateUniqueNonce();
 660 |       const signature = await signL1Action(this.wallet, action, null, nonce, this.IS_MAINNET);
 661 | 
 662 |       const payload = { action, nonce, signature };
 663 |       return this.httpApi.makeRequest(payload, 1);
 664 |     } catch (error) {
 665 |       throw error;
 666 |     }
 667 |   }
 668 | 
 669 |   // Create a new vault
 670 |   async createVault(
 671 |     name: string,
 672 |     description: string,
 673 |     initialUsd: number
 674 |   ): Promise<CreateVaultResponse> {
 675 |     await this.parent.ensureInitialized();
 676 |     try {
 677 |       const nonce = this.generateUniqueNonce();
 678 |       const action = {
 679 |         type: ExchangeType.CREATE_VAULT,
 680 |         name,
 681 |         description,
 682 |         initialUsd,
 683 |         nonce,
 684 |       };
 685 |       const signature = await signL1Action(this.wallet, action, null, nonce, this.IS_MAINNET);
 686 | 
 687 |       const payload = { action, nonce, signature };
 688 |       return this.httpApi.makeRequest(payload, 1);
 689 |     } catch (error) {
 690 |       throw error;
 691 |     }
 692 |   }
 693 | 
 694 |   // Distribute funds from a vault between followers
 695 |   async vaultDistribute(vaultAddress: string, usd: number): Promise<any> {
 696 |     await this.parent.ensureInitialized();
 697 |     try {
 698 |       const action = {
 699 |         type: ExchangeType.VAULT_DISTRIBUTE,
 700 |         vaultAddress,
 701 |         usd,
 702 |       };
 703 |       const nonce = this.generateUniqueNonce();
 704 |       const signature = await signL1Action(this.wallet, action, null, nonce, this.IS_MAINNET);
 705 | 
 706 |       const payload = { action, nonce, signature };
 707 |       return this.httpApi.makeRequest(payload, 1);
 708 |     } catch (error) {
 709 |       throw error;
 710 |     }
 711 |   }
 712 | 
 713 |   // Modify a vault's configuration
 714 |   async vaultModify(
 715 |     vaultAddress: string,
 716 |     allowDeposits: boolean | null,
 717 |     alwaysCloseOnWithdraw: boolean | null
 718 |   ): Promise<any> {
 719 |     await this.parent.ensureInitialized();
 720 |     try {
 721 |       const action = {
 722 |         type: ExchangeType.VAULT_MODIFY,
 723 |         vaultAddress,
 724 |         allowDeposits,
 725 |         alwaysCloseOnWithdraw,
 726 |       };
 727 |       const nonce = this.generateUniqueNonce();
 728 |       const signature = await signL1Action(this.wallet, action, null, nonce, this.IS_MAINNET);
 729 | 
 730 |       const payload = { action, nonce, signature };
 731 |       return this.httpApi.makeRequest(payload, 1);
 732 |     } catch (error) {
 733 |       throw error;
 734 |     }
 735 |   }
 736 | 
 737 |   async setReferrer(code: string = CONSTANTS.SDK_CODE): Promise<any> {
 738 |     await this.parent.ensureInitialized();
 739 |     try {
 740 |       const action = {
 741 |         type: ExchangeType.SET_REFERRER,
 742 |         code,
 743 |       };
 744 |       const nonce = this.generateUniqueNonce();
 745 |       const signature = await signL1Action(this.wallet, action, null, nonce, this.IS_MAINNET);
 746 | 
 747 |       const payload = { action, nonce, signature };
 748 |       return this.httpApi.makeRequest(payload, 1);
 749 |     } catch (error) {
 750 |       throw error;
 751 |     }
 752 |   }
 753 | 
 754 |   async modifyUserEvm(usingBigBlocks: boolean): Promise<any> {
 755 |     await this.parent.ensureInitialized();
 756 |     try {
 757 |       const action = { type: ExchangeType.EVM_USER_MODIFY, usingBigBlocks };
 758 |       const nonce = this.generateUniqueNonce();
 759 |       const signature = await signL1Action(this.wallet, action, null, nonce, this.IS_MAINNET);
 760 | 
 761 |       const payload = { action, nonce, signature };
 762 |       return this.httpApi.makeRequest(payload, 1);
 763 |     } catch (error) {
 764 |       throw error;
 765 |     }
 766 |   }
 767 | 
 768 |   async placeTwapOrder(orderRequest: TwapOrder): Promise<TwapOrderResponse> {
 769 |     await this.parent.ensureInitialized();
 770 |     try {
 771 |       const assetIndex = await this.getAssetIndex(orderRequest.coin);
 772 |       const vaultAddress = this.getVaultAddress();
 773 | 
 774 |       const twapWire = {
 775 |         a: assetIndex,
 776 |         b: orderRequest.is_buy,
 777 |         s: orderRequest.sz.toString(),
 778 |         r: orderRequest.reduce_only,
 779 |         m: orderRequest.minutes,
 780 |         t: orderRequest.randomize,
 781 |       };
 782 | 
 783 |       const action = {
 784 |         type: ExchangeType.TWAP_ORDER,
 785 |         twap: twapWire,
 786 |       };
 787 | 
 788 |       const nonce = this.generateUniqueNonce();
 789 |       const signature = await signL1Action(
 790 |         this.wallet,
 791 |         action,
 792 |         vaultAddress,
 793 |         nonce,
 794 |         this.IS_MAINNET
 795 |       );
 796 | 
 797 |       const payload = { action, nonce, signature, vaultAddress };
 798 |       return this.httpApi.makeRequest(payload, 1);
 799 |     } catch (error) {
 800 |       throw error;
 801 |     }
 802 |   }
 803 | 
 804 |   async cancelTwapOrder(cancelRequest: TwapCancelRequest): Promise<TwapCancelResponse> {
 805 |     await this.parent.ensureInitialized();
 806 |     try {
 807 |       const assetIndex = await this.getAssetIndex(cancelRequest.coin);
 808 |       const vaultAddress = this.getVaultAddress();
 809 | 
 810 |       const action = {
 811 |         type: ExchangeType.TWAP_CANCEL,
 812 |         a: assetIndex,
 813 |         t: cancelRequest.twap_id,
 814 |       };
 815 | 
 816 |       const nonce = this.generateUniqueNonce();
 817 |       const signature = await signL1Action(
 818 |         this.wallet,
 819 |         action,
 820 |         vaultAddress,
 821 |         nonce,
 822 |         this.IS_MAINNET
 823 |       );
 824 | 
 825 |       const payload = { action, nonce, signature, vaultAddress };
 826 |       return this.httpApi.makeRequest(payload, 1);
 827 |     } catch (error) {
 828 |       throw error;
 829 |     }
 830 |   }
 831 | 
 832 |   async approveAgent(request: ApproveAgentRequest): Promise<any> {
 833 |     await this.parent.ensureInitialized();
 834 |     try {
 835 |       const nonce = this.generateUniqueNonce();
 836 |       const action = {
 837 |         type: ExchangeType.APPROVE_AGENT,
 838 |         hyperliquidChain: this.IS_MAINNET ? 'Mainnet' : 'Testnet',
 839 |         signatureChainId: this.IS_MAINNET ? CHAIN_IDS.ARBITRUM_MAINNET : CHAIN_IDS.ARBITRUM_TESTNET,
 840 |         agentAddress: request.agentAddress,
 841 |         agentName: request.agentName,
 842 |         nonce: nonce,
 843 |       };
 844 | 
 845 |       const signature = await signAgent(this.wallet, action, this.IS_MAINNET);
 846 | 
 847 |       const payload = { action, nonce: action.nonce, signature };
 848 |       return this.httpApi.makeRequest(payload, 1);
 849 |     } catch (error) {
 850 |       throw error;
 851 |     }
 852 |   }
 853 | 
 854 |   async approveBuilderFee(request: ApproveBuilderFeeRequest): Promise<any> {
 855 |     await this.parent.ensureInitialized();
 856 |     try {
 857 |       // Use timestamp for nonce to match successful request format
 858 |       const nonce = Date.now();
 859 | 
 860 |       // Ensure the builder address is lowercase
 861 |       const builderAddress = request.builder.toLowerCase();
 862 | 
 863 |       // Create the action object with exact same structure as successful request
 864 |       const action = {
 865 |         type: ExchangeType.APPROVE_BUILDER_FEE,
 866 |         hyperliquidChain: this.IS_MAINNET ? 'Mainnet' : 'Testnet',
 867 |         signatureChainId: this.IS_MAINNET ? CHAIN_IDS.ARBITRUM_MAINNET : CHAIN_IDS.ARBITRUM_TESTNET,
 868 |         // Ensure maxFeeRate always includes the % symbol
 869 |         maxFeeRate: request.maxFeeRate.endsWith('%')
 870 |           ? request.maxFeeRate
 871 |           : `${request.maxFeeRate}%`,
 872 |         builder: builderAddress,
 873 |         nonce: nonce,
 874 |       };
 875 | 
 876 |       // Sign the action with the correct types
 877 |       const signature = await signUserSignedAction(
 878 |         this.wallet,
 879 |         action,
 880 |         [
 881 |           { name: 'hyperliquidChain', type: 'string' },
 882 |           { name: 'maxFeeRate', type: 'string' },
 883 |           { name: 'builder', type: 'address' },
 884 |           { name: 'nonce', type: 'uint64' },
 885 |         ],
 886 |         'HyperliquidTransaction:ApproveBuilderFee',
 887 |         this.IS_MAINNET
 888 |       );
 889 | 
 890 |       // Create the payload with the exact same structure as successful request
 891 |       const payload = {
 892 |         action,
 893 |         nonce: action.nonce,
 894 |         signature,
 895 |       };
 896 | 
 897 |       return this.httpApi.makeRequest(payload, 1);
 898 |     } catch (error) {
 899 |       console.error('Error in approveBuilderFee:', error);
 900 |       throw error;
 901 |     }
 902 |   }
 903 | 
 904 |   // Claim staking rewards
 905 |   async claimRewards(): Promise<ClaimRewardsResponse> {
 906 |     await this.parent.ensureInitialized();
 907 |     try {
 908 |       const action = {
 909 |         type: ExchangeType.CLAIM_REWARDS,
 910 |       };
 911 |       const nonce = this.generateUniqueNonce();
 912 |       const signature = await signL1Action(this.wallet, action, null, nonce, this.IS_MAINNET);
 913 | 
 914 |       const payload = { action, nonce, signature };
 915 |       return this.httpApi.makeRequest(payload, 1);
 916 |     } catch (error) {
 917 |       throw error;
 918 |     }
 919 |   }
 920 | 
 921 |   // Create a sub-account
 922 |   async createSubAccount(name: string): Promise<CreateSubAccountResponse> {
 923 |     await this.parent.ensureInitialized();
 924 |     try {
 925 |       const action = {
 926 |         type: ExchangeType.CREATE_SUB_ACCOUNT,
 927 |         name,
 928 |       };
 929 |       const nonce = this.generateUniqueNonce();
 930 |       const signature = await signL1Action(this.wallet, action, null, nonce, this.IS_MAINNET);
 931 | 
 932 |       const payload = { action, nonce, signature };
 933 |       return this.httpApi.makeRequest(payload, 1);
 934 |     } catch (error) {
 935 |       throw error;
 936 |     }
 937 |   }
 938 | 
 939 |   // Set display name in the leaderboard
 940 |   async setDisplayName(displayName: string): Promise<SetDisplayNameResponse> {
 941 |     await this.parent.ensureInitialized();
 942 |     try {
 943 |       const action = {
 944 |         type: ExchangeType.SET_DISPLAY_NAME,
 945 |         displayName,
 946 |       };
 947 |       const nonce = this.generateUniqueNonce();
 948 |       const signature = await signL1Action(this.wallet, action, null, nonce, this.IS_MAINNET);
 949 | 
 950 |       const payload = { action, nonce, signature };
 951 |       return this.httpApi.makeRequest(payload, 1);
 952 |     } catch (error) {
 953 |       throw error;
 954 |     }
 955 |   }
 956 | 
 957 |   // Opt out of spot dusting
 958 |   async spotUser(optOut: boolean): Promise<SpotUserResponse> {
 959 |     await this.parent.ensureInitialized();
 960 |     try {
 961 |       const action = {
 962 |         type: ExchangeType.SPOT_USER,
 963 |         toggleSpotDusting: {
 964 |           optOut,
 965 |         },
 966 |       };
 967 |       const nonce = this.generateUniqueNonce();
 968 |       const signature = await signL1Action(this.wallet, action, null, nonce, this.IS_MAINNET);
 969 | 
 970 |       const payload = { action, nonce, signature };
 971 |       return this.httpApi.makeRequest(payload, 1);
 972 |     } catch (error) {
 973 |       throw error;
 974 |     }
 975 |   }
 976 | 
 977 |   // Deposit into staking
 978 |   async cDeposit(wei: bigint): Promise<CDepositResponse> {
 979 |     await this.parent.ensureInitialized();
 980 |     try {
 981 |       const nonce = this.generateUniqueNonce();
 982 |       const action = {
 983 |         type: ExchangeType.C_DEPOSIT,
 984 |         hyperliquidChain: this.IS_MAINNET ? 'Mainnet' : 'Testnet',
 985 |         signatureChainId: this.IS_MAINNET ? CHAIN_IDS.ARBITRUM_MAINNET : CHAIN_IDS.ARBITRUM_TESTNET,
 986 |         wei: wei.toString(),
 987 |         nonce,
 988 |       };
 989 | 
 990 |       const signature = await signUserSignedAction(
 991 |         this.wallet,
 992 |         action,
 993 |         [
 994 |           { name: 'hyperliquidChain', type: 'string' },
 995 |           { name: 'wei', type: 'string' },
 996 |           { name: 'nonce', type: 'uint64' },
 997 |         ],
 998 |         'HyperliquidTransaction:CDeposit',
 999 |         this.IS_MAINNET
1000 |       );
1001 | 
1002 |       const payload = { action, nonce: action.nonce, signature };
1003 |       return this.httpApi.makeRequest(payload, 1);
1004 |     } catch (error) {
1005 |       throw error;
1006 |     }
1007 |   }
1008 | 
1009 |   // Withdraw from staking
1010 |   async cWithdraw(wei: bigint): Promise<CWithdrawResponse> {
1011 |     await this.parent.ensureInitialized();
1012 |     try {
1013 |       const nonce = this.generateUniqueNonce();
1014 |       const action = {
1015 |         type: ExchangeType.C_WITHDRAW,
1016 |         hyperliquidChain: this.IS_MAINNET ? 'Mainnet' : 'Testnet',
1017 |         signatureChainId: this.IS_MAINNET ? CHAIN_IDS.ARBITRUM_MAINNET : CHAIN_IDS.ARBITRUM_TESTNET,
1018 |         wei: wei.toString(),
1019 |         nonce,
1020 |       };
1021 | 
1022 |       const signature = await signUserSignedAction(
1023 |         this.wallet,
1024 |         action,
1025 |         [
1026 |           { name: 'hyperliquidChain', type: 'string' },
1027 |           { name: 'wei', type: 'string' },
1028 |           { name: 'nonce', type: 'uint64' },
1029 |         ],
1030 |         'HyperliquidTransaction:CWithdraw',
1031 |         this.IS_MAINNET
1032 |       );
1033 | 
1034 |       const payload = { action, nonce: action.nonce, signature };
1035 |       return this.httpApi.makeRequest(payload, 1);
1036 |     } catch (error) {
1037 |       throw error;
1038 |     }
1039 |   }
1040 | 
1041 |   // Delegate or undelegate stake from validator
1042 |   async tokenDelegate(
1043 |     validator: string,
1044 |     isUndelegate: boolean,
1045 |     wei: bigint
1046 |   ): Promise<TokenDelegateResponse> {
1047 |     await this.parent.ensureInitialized();
1048 |     try {
1049 |       const nonce = this.generateUniqueNonce();
1050 |       const action = {
1051 |         type: ExchangeType.TOKEN_DELEGATE,
1052 |         validator,
1053 |         isUndelegate,
1054 |         wei: wei.toString(),
1055 |         nonce,
1056 |       };
1057 | 
1058 |       const signature = await signL1Action(this.wallet, action, null, nonce, this.IS_MAINNET);
1059 | 
1060 |       const payload = { action, nonce, signature };
1061 |       return this.httpApi.makeRequest(payload, 1);
1062 |     } catch (error) {
1063 |       throw error;
1064 |     }
1065 |   }
1066 | 
1067 |   // Transfer between sub-accounts (spot)
1068 |   async subAccountSpotTransfer(
1069 |     subAccountUser: string,
1070 |     isDeposit: boolean,
1071 |     token: number,
1072 |     amount: string
1073 |   ): Promise<SubAccountSpotTransferResponse> {
1074 |     await this.parent.ensureInitialized();
1075 |     try {
1076 |       const nonce = this.generateUniqueNonce();
1077 |       const action = {
1078 |         type: ExchangeType.SUB_ACCOUNT_SPOT_TRANSFER,
1079 |         subAccountUser,
1080 |         isDeposit,
1081 |         token,
1082 |         amount,
1083 |       };
1084 | 
1085 |       const signature = await signL1Action(this.wallet, action, null, nonce, this.IS_MAINNET);
1086 | 
1087 |       const payload = { action, nonce, signature };
1088 |       return this.httpApi.makeRequest(payload, 1);
1089 |     } catch (error) {
1090 |       throw error;
1091 |     }
1092 |   }
1093 | 
1094 |   /**
1095 |    * Reserve additional actions for 0.0005 USDC per request instead of trading to increase rate limits
1096 |    * @param weight The weight to reserve (as a number)
1097 |    * @returns Response indicating success or failure
1098 |    */
1099 |   async reserveRequestWeight(weight: number): Promise<ReserveRequestWeightResponse> {
1100 |     await this.parent.ensureInitialized();
1101 |     try {
1102 |       const vaultAddress = this.getVaultAddress();
1103 |       const action = {
1104 |         type: ExchangeType.RESERVE_REQUEST_WEIGHT,
1105 |         weight: weight,
1106 |       };
1107 | 
1108 |       const nonce = this.generateUniqueNonce();
1109 |       const signature = await signL1Action(
1110 |         this.wallet,
1111 |         action,
1112 |         vaultAddress,
1113 |         nonce,
1114 |         this.IS_MAINNET
1115 |       );
1116 | 
1117 |       const payload = { action, nonce, signature, vaultAddress };
1118 |       return this.httpApi.makeRequest(payload, 1);
1119 |     } catch (error) {
1120 |       throw error;
1121 |     }
1122 |   }
1123 | 
1124 |   // Transfer between sub-accounts (perp)
1125 |   async subAccountTransfer(
1126 |     subAccountUser: string,
1127 |     isDeposit: boolean,
1128 |     usd: number
1129 |   ): Promise<SubAccountTransferResponse> {
1130 |     await this.parent.ensureInitialized();
1131 |     try {
1132 |       const nonce = this.generateUniqueNonce();
1133 |       const action = {
1134 |         type: ExchangeType.SUB_ACCOUNT_TRANSFER,
1135 |         subAccountUser,
1136 |         isDeposit,
1137 |         usd,
1138 |       };
1139 | 
1140 |       const signature = await signL1Action(this.wallet, action, null, nonce, this.IS_MAINNET);
1141 | 
1142 |       const payload = { action, nonce, signature };
1143 |       return this.httpApi.makeRequest(payload, 1);
1144 |     } catch (error) {
1145 |       throw error;
1146 |     }
1147 |   }
1148 | 
1149 |   /**
1150 |    * Generates a unique nonce by using the current timestamp in milliseconds
1151 |    * If multiple calls happen in the same millisecond, it ensures the nonce is still increasing
1152 |    * @returns A unique nonce value
1153 |    */
1154 |   private generateUniqueNonce(): number {
1155 |     const timestamp = Date.now();
1156 | 
1157 |     // Ensure the nonce is always greater than the previous one
1158 |     if (timestamp <= this.lastNonceTimestamp) {
1159 |       // If we're in the same millisecond, increment by 1 from the last nonce
1160 |       this.lastNonceTimestamp += 1;
1161 |       return this.lastNonceTimestamp;
1162 |     }
1163 | 
1164 |     // Otherwise use the current timestamp
1165 |     this.lastNonceTimestamp = timestamp;
1166 |     return timestamp;
1167 |   }
1168 | }
1169 | 


--------------------------------------------------------------------------------
/src/rest/info.ts:
--------------------------------------------------------------------------------
  1 | import { RateLimiter } from '../utils/rateLimiter';
  2 | import { GeneralInfoAPI } from './info/general';
  3 | import { SpotInfoAPI } from './info/spot';
  4 | import { PerpetualsInfoAPI } from './info/perpetuals';
  5 | import { HttpApi } from '../utils/helpers';
  6 | import { SymbolConversion } from '../utils/symbolConversion';
  7 | import { Hyperliquid } from '../index';
  8 | 
  9 | import {
 10 |   AllMids,
 11 |   Meta,
 12 |   UserOpenOrders,
 13 |   FrontendOpenOrders,
 14 |   UserFills,
 15 |   UserRateLimit,
 16 |   OrderStatus,
 17 |   L2Book,
 18 |   CandleSnapshot,
 19 |   VaultEquity,
 20 |   HistoricalOrder,
 21 |   TwapSliceFill,
 22 |   SubAccount,
 23 |   VaultDetails,
 24 |   DelegatorReward,
 25 |   DelegatorHistoryEntry,
 26 |   DelegatorSummary,
 27 |   Delegation,
 28 |   UserRole,
 29 |   ValidatorSummary,
 30 |   VaultSummary,
 31 |   UserFees,
 32 |   PortfolioPeriods,
 33 |   PreTransferCheck,
 34 |   Referral,
 35 |   ExtraAgent,
 36 |   LegalCheck,
 37 |   TwapHistory,
 38 |   MultiSigSigners,
 39 | } from '../types/index';
 40 | 
 41 | import { InfoType, ENDPOINTS } from '../types/constants';
 42 | 
 43 | export class InfoAPI {
 44 |   public spot: SpotInfoAPI;
 45 |   public perpetuals: PerpetualsInfoAPI;
 46 |   private httpApi: HttpApi;
 47 |   private generalAPI: GeneralInfoAPI;
 48 |   private symbolConversion: SymbolConversion;
 49 |   private parent: Hyperliquid;
 50 | 
 51 |   constructor(
 52 |     baseURL: string,
 53 |     rateLimiter: RateLimiter,
 54 |     symbolConversion: SymbolConversion,
 55 |     parent: Hyperliquid
 56 |   ) {
 57 |     this.httpApi = new HttpApi(baseURL, ENDPOINTS.INFO, rateLimiter);
 58 |     this.symbolConversion = symbolConversion;
 59 |     this.parent = parent;
 60 | 
 61 |     this.generalAPI = new GeneralInfoAPI(this.httpApi, this.symbolConversion, this.parent);
 62 |     this.spot = new SpotInfoAPI(this.httpApi, this.symbolConversion);
 63 |     this.perpetuals = new PerpetualsInfoAPI(this.httpApi, this.symbolConversion, this.parent);
 64 |   }
 65 | 
 66 |   async getAssetIndex(assetName: string): Promise<number | undefined> {
 67 |     await this.parent.ensureInitialized();
 68 |     return await this.symbolConversion.getAssetIndex(assetName);
 69 |   }
 70 | 
 71 |   async getInternalName(exchangeName: string): Promise<string | undefined> {
 72 |     await this.parent.ensureInitialized();
 73 |     return await this.symbolConversion.convertSymbol(exchangeName);
 74 |   }
 75 | 
 76 |   async getAllAssets(): Promise<{ perp: string[]; spot: string[] }> {
 77 |     await this.parent.ensureInitialized();
 78 |     return await this.symbolConversion.getAllAssets();
 79 |   }
 80 | 
 81 |   async getAllMids(rawResponse: boolean = false): Promise<AllMids> {
 82 |     await this.parent.ensureInitialized();
 83 |     return this.generalAPI.getAllMids(rawResponse);
 84 |   }
 85 | 
 86 |   async getUserOpenOrders(user: string, rawResponse: boolean = false): Promise<UserOpenOrders> {
 87 |     await this.parent.ensureInitialized();
 88 |     return this.generalAPI.getUserOpenOrders(user, rawResponse);
 89 |   }
 90 | 
 91 |   async getFrontendOpenOrders(
 92 |     user: string,
 93 |     rawResponse: boolean = false
 94 |   ): Promise<FrontendOpenOrders> {
 95 |     await this.parent.ensureInitialized();
 96 |     return this.generalAPI.getFrontendOpenOrders(user, rawResponse);
 97 |   }
 98 | 
 99 |   async getUserFills(user: string, rawResponse: boolean = false): Promise<UserFills> {
100 |     await this.parent.ensureInitialized();
101 |     return this.generalAPI.getUserFills(user, rawResponse);
102 |   }
103 | 
104 |   async getUserFillsByTime(
105 |     user: string,
106 |     startTime: number,
107 |     endTime: number,
108 |     rawResponse: boolean = false
109 |   ): Promise<UserFills> {
110 |     await this.parent.ensureInitialized();
111 |     return this.generalAPI.getUserFillsByTime(user, startTime, endTime, rawResponse);
112 |   }
113 | 
114 |   async getUserRateLimit(user: string, rawResponse: boolean = false): Promise<UserRateLimit> {
115 |     await this.parent.ensureInitialized();
116 |     return this.generalAPI.getUserRateLimit(user, rawResponse);
117 |   }
118 | 
119 |   async getOrderStatus(
120 |     user: string,
121 |     oid: number | string,
122 |     rawResponse: boolean = false
123 |   ): Promise<OrderStatus> {
124 |     await this.parent.ensureInitialized();
125 |     return this.generalAPI.getOrderStatus(user, oid, rawResponse);
126 |   }
127 | 
128 |   async getL2Book(coin: string, rawResponse: boolean = false, nSigFigs: number = 5, mantissa: number = undefined): Promise<L2Book> {
129 |     await this.parent.ensureInitialized();
130 |     return this.generalAPI.getL2Book(coin, rawResponse, nSigFigs, mantissa);
131 |   }
132 | 
133 |   async getCandleSnapshot(
134 |     coin: string,
135 |     interval: string,
136 |     startTime: number,
137 |     endTime: number,
138 |     rawResponse: boolean = false
139 |   ): Promise<CandleSnapshot> {
140 |     await this.parent.ensureInitialized();
141 |     return this.generalAPI.getCandleSnapshot(coin, interval, startTime, endTime, rawResponse);
142 |   }
143 | 
144 |   async getMaxBuilderFee(
145 |     user: string,
146 |     builder: string,
147 |     rawResponse: boolean = false
148 |   ): Promise<number> {
149 |     await this.parent.ensureInitialized();
150 |     return this.generalAPI.getMaxBuilderFee(user, builder, rawResponse);
151 |   }
152 | 
153 |   async getHistoricalOrders(
154 |     user: string,
155 |     rawResponse: boolean = false
156 |   ): Promise<HistoricalOrder[]> {
157 |     await this.parent.ensureInitialized();
158 |     return this.generalAPI.getHistoricalOrders(user, rawResponse);
159 |   }
160 | 
161 |   async getUserTwapSliceFills(
162 |     user: string,
163 |     rawResponse: boolean = false
164 |   ): Promise<TwapSliceFill[]> {
165 |     await this.parent.ensureInitialized();
166 |     return this.generalAPI.getUserTwapSliceFills(user, rawResponse);
167 |   }
168 | 
169 |   async getSubAccounts(user: string, rawResponse: boolean = false): Promise<SubAccount[]> {
170 |     await this.parent.ensureInitialized();
171 |     return this.generalAPI.getSubAccounts(user, rawResponse);
172 |   }
173 | 
174 |   async getVaultDetails(
175 |     vaultAddress: string,
176 |     user?: string,
177 |     rawResponse: boolean = false
178 |   ): Promise<VaultDetails> {
179 |     await this.parent.ensureInitialized();
180 |     return this.generalAPI.getVaultDetails(vaultAddress, user, rawResponse);
181 |   }
182 | 
183 |   async getUserVaultEquities(user: string, rawResponse: boolean = false): Promise<VaultEquity[]> {
184 |     await this.parent.ensureInitialized();
185 |     return this.generalAPI.getUserVaultEquities(user, rawResponse);
186 |   }
187 | 
188 |   async getUserRole(user: string, rawResponse: boolean = false): Promise<UserRole> {
189 |     await this.parent.ensureInitialized();
190 |     return this.generalAPI.getUserRole(user, rawResponse);
191 |   }
192 | 
193 |   async getDelegations(user: string, rawResponse: boolean = false): Promise<Delegation[]> {
194 |     await this.parent.ensureInitialized();
195 |     return this.generalAPI.getDelegations(user, rawResponse);
196 |   }
197 | 
198 |   async getDelegatorSummary(user: string, rawResponse: boolean = false): Promise<DelegatorSummary> {
199 |     await this.parent.ensureInitialized();
200 |     return this.generalAPI.getDelegatorSummary(user, rawResponse);
201 |   }
202 | 
203 |   async getDelegatorHistory(
204 |     user: string,
205 |     rawResponse: boolean = false
206 |   ): Promise<DelegatorHistoryEntry[]> {
207 |     await this.parent.ensureInitialized();
208 |     return this.generalAPI.getDelegatorHistory(user, rawResponse);
209 |   }
210 | 
211 |   async getDelegatorRewards(
212 |     user: string,
213 |     rawResponse: boolean = false
214 |   ): Promise<DelegatorReward[]> {
215 |     await this.parent.ensureInitialized();
216 |     return this.generalAPI.getDelegatorRewards(user, rawResponse);
217 |   }
218 | 
219 |   async validatorSummaries(rawResponse: boolean = false): Promise<ValidatorSummary[]> {
220 |     await this.parent.ensureInitialized();
221 |     return this.generalAPI.validatorSummaries(rawResponse);
222 |   }
223 | 
224 |   async vaultSummaries(rawResponse: boolean = false): Promise<VaultSummary[]> {
225 |     await this.parent.ensureInitialized();
226 |     return this.generalAPI.vaultSummaries(rawResponse);
227 |   }
228 | 
229 |   async userFees(user: string, rawResponse: boolean = false): Promise<UserFees> {
230 |     await this.parent.ensureInitialized();
231 |     return this.generalAPI.userFees(user, rawResponse);
232 |   }
233 | 
234 |   async portfolio(user: string, rawResponse: boolean = false): Promise<PortfolioPeriods> {
235 |     await this.parent.ensureInitialized();
236 |     return this.generalAPI.portfolio(user, rawResponse);
237 |   }
238 | 
239 |   async preTransferCheck(
240 |     user: string,
241 |     source: string,
242 |     rawResponse: boolean = false
243 |   ): Promise<PreTransferCheck> {
244 |     await this.parent.ensureInitialized();
245 |     return this.generalAPI.preTransferCheck(user, source, rawResponse);
246 |   }
247 | 
248 |   async referral(user: string, rawResponse: boolean = false): Promise<Referral> {
249 |     await this.parent.ensureInitialized();
250 |     return this.generalAPI.referral(user, rawResponse);
251 |   }
252 | 
253 |   async extraAgents(user: string, rawResponse: boolean = false): Promise<ExtraAgent[]> {
254 |     await this.parent.ensureInitialized();
255 |     return this.generalAPI.extraAgents(user, rawResponse);
256 |   }
257 | 
258 |   async isVip(user: string, rawResponse: boolean = false): Promise<boolean> {
259 |     await this.parent.ensureInitialized();
260 |     return this.generalAPI.isVip(user, rawResponse);
261 |   }
262 | 
263 |   async legalCheck(user: string, rawResponse: boolean = false): Promise<LegalCheck> {
264 |     await this.parent.ensureInitialized();
265 |     return this.generalAPI.legalCheck(user, rawResponse);
266 |   }
267 | 
268 |   async userTwapSliceFillsByTime(
269 |     user: string,
270 |     startTime: number,
271 |     endTime?: number,
272 |     aggregateByTime?: boolean,
273 |     rawResponse: boolean = false
274 |   ): Promise<TwapSliceFill[]> {
275 |     await this.parent.ensureInitialized();
276 |     return this.generalAPI.userTwapSliceFillsByTime(
277 |       user,
278 |       startTime,
279 |       endTime,
280 |       aggregateByTime,
281 |       rawResponse
282 |     );
283 |   }
284 | 
285 |   async twapHistory(user: string, rawResponse: boolean = false): Promise<TwapHistory[]> {
286 |     await this.parent.ensureInitialized();
287 |     return this.generalAPI.twapHistory(user, rawResponse);
288 |   }
289 | 
290 |   async userToMultiSigSigners(
291 |     user: string,
292 |     rawResponse: boolean = false
293 |   ): Promise<MultiSigSigners | null> {
294 |     await this.parent.ensureInitialized();
295 |     return this.generalAPI.userToMultiSigSigners(user, rawResponse);
296 |   }
297 | }
298 | 


--------------------------------------------------------------------------------
/src/rest/info/general.ts:
--------------------------------------------------------------------------------
  1 | // src/rest/info/general.ts
  2 | 
  3 | import {
  4 |   AllMids,
  5 |   Meta,
  6 |   UserOpenOrders,
  7 |   FrontendOpenOrders,
  8 |   UserFills,
  9 |   UserRateLimit,
 10 |   OrderStatus,
 11 |   L2Book,
 12 |   CandleSnapshot,
 13 |   HistoricalOrder,
 14 |   TwapSliceFill,
 15 |   SubAccount,
 16 |   VaultDetails,
 17 |   VaultEquity,
 18 |   UserRole,
 19 |   Delegation,
 20 |   DelegatorSummary,
 21 |   DelegatorHistoryEntry,
 22 |   DelegatorReward,
 23 |   ValidatorSummary,
 24 |   VaultSummary,
 25 |   UserFees,
 26 |   PortfolioPeriods,
 27 |   PreTransferCheck,
 28 |   Referral,
 29 |   ExtraAgent,
 30 |   LegalCheck,
 31 |   TwapHistory,
 32 |   MultiSigSigners,
 33 | } from '../../types';
 34 | import { HttpApi } from '../../utils/helpers';
 35 | import { SymbolConversion } from '../../utils/symbolConversion';
 36 | import { InfoType } from '../../types/constants';
 37 | import { Hyperliquid } from '../../index';
 38 | 
 39 | export class GeneralInfoAPI {
 40 |   private parent: Hyperliquid;
 41 | 
 42 |   constructor(
 43 |     private httpApi: HttpApi,
 44 |     private symbolConversion: SymbolConversion,
 45 |     parent: Hyperliquid
 46 |   ) {
 47 |     this.parent = parent;
 48 |   }
 49 | 
 50 |   async getAllMids(rawResponse: boolean = false): Promise<AllMids> {
 51 |     const response = await this.httpApi.makeRequest<AllMids>({ type: InfoType.ALL_MIDS });
 52 | 
 53 |     if (rawResponse) {
 54 |       return response;
 55 |     } else {
 56 |       const convertedResponse: any = {};
 57 |       for (const [key, value] of Object.entries(response)) {
 58 |         const convertedKey = await this.symbolConversion.convertSymbol(key);
 59 |         const convertedValue = parseFloat(value as string);
 60 |         convertedResponse[convertedKey] = convertedValue;
 61 |       }
 62 |       return convertedResponse;
 63 |     }
 64 |   }
 65 | 
 66 |   async getUserOpenOrders(user: string, rawResponse: boolean = false): Promise<UserOpenOrders> {
 67 |     await this.parent.ensureInitialized();
 68 |     const response = await this.httpApi.makeRequest({ type: InfoType.OPEN_ORDERS, user: user });
 69 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
 70 |   }
 71 | 
 72 |   async getFrontendOpenOrders(
 73 |     user: string,
 74 |     rawResponse: boolean = false
 75 |   ): Promise<FrontendOpenOrders> {
 76 |     const response = await this.httpApi.makeRequest(
 77 |       { type: InfoType.FRONTEND_OPEN_ORDERS, user: user },
 78 |       20
 79 |     );
 80 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
 81 |   }
 82 | 
 83 |   async getUserFills(user: string, rawResponse: boolean = false): Promise<UserFills> {
 84 |     const response = await this.httpApi.makeRequest({ type: InfoType.USER_FILLS, user: user }, 20);
 85 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
 86 |   }
 87 | 
 88 |   async getUserFillsByTime(
 89 |     user: string,
 90 |     startTime: number,
 91 |     endTime?: number,
 92 |     rawResponse: boolean = false
 93 |   ): Promise<UserFills> {
 94 |     let params: { user: string; startTime: number; type: string; endTime?: number } = {
 95 |       user: user,
 96 |       startTime: Math.round(startTime),
 97 |       type: InfoType.USER_FILLS_BY_TIME,
 98 |     };
 99 | 
100 |     if (endTime) {
101 |       params.endTime = Math.round(endTime);
102 |     }
103 | 
104 |     const response = await this.httpApi.makeRequest(params, 20);
105 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
106 |   }
107 | 
108 |   async getUserRateLimit(user: string, rawResponse: boolean = false): Promise<UserRateLimit> {
109 |     const response = await this.httpApi.makeRequest(
110 |       { type: InfoType.USER_RATE_LIMIT, user: user },
111 |       20
112 |     );
113 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
114 |   }
115 | 
116 |   async getOrderStatus(
117 |     user: string,
118 |     oid: number | string,
119 |     rawResponse: boolean = false
120 |   ): Promise<OrderStatus> {
121 |     const response = await this.httpApi.makeRequest({
122 |       type: InfoType.ORDER_STATUS,
123 |       user: user,
124 |       oid: oid,
125 |     });
126 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
127 |   }
128 | 
129 |   async getL2Book(coin: string, rawResponse: boolean = false, nSigFigs: number = 5, mantissa: number= undefined): Promise<L2Book> {
130 |     const response = await this.httpApi.makeRequest({
131 |       type: InfoType.L2_BOOK,
132 |       coin: await this.symbolConversion.convertSymbol(coin, 'reverse'),
133 |       nSigFigs,
134 |       mantissa
135 |     });
136 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
137 |   }
138 | 
139 |   async getCandleSnapshot(
140 |     coin: string,
141 |     interval: string,
142 |     startTime: number,
143 |     endTime: number,
144 |     rawResponse: boolean = false
145 |   ): Promise<CandleSnapshot> {
146 |     const response = await this.httpApi.makeRequest({
147 |       type: InfoType.CANDLE_SNAPSHOT,
148 |       req: {
149 |         coin: await this.symbolConversion.convertSymbol(coin, 'reverse'),
150 |         interval: interval,
151 |         startTime: startTime,
152 |         endTime: endTime,
153 |       },
154 |     });
155 | 
156 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response, ['s']);
157 |   }
158 | 
159 |   // Add these methods to src/rest/info/general.ts
160 | 
161 |   async getMaxBuilderFee(
162 |     user: string,
163 |     builder: string,
164 |     rawResponse: boolean = false
165 |   ): Promise<number> {
166 |     const response = await this.httpApi.makeRequest({
167 |       type: InfoType.MAX_BUILDER_FEE,
168 |       user,
169 |       builder,
170 |     });
171 |     return rawResponse ? response : this.symbolConversion.convertToNumber(response);
172 |   }
173 | 
174 |   async getHistoricalOrders(
175 |     user: string,
176 |     rawResponse: boolean = false
177 |   ): Promise<HistoricalOrder[]> {
178 |     const response = await this.httpApi.makeRequest({
179 |       type: InfoType.HISTORICAL_ORDERS,
180 |       user,
181 |     });
182 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
183 |   }
184 | 
185 |   async getUserTwapSliceFills(
186 |     user: string,
187 |     rawResponse: boolean = false
188 |   ): Promise<TwapSliceFill[]> {
189 |     const response = await this.httpApi.makeRequest({
190 |       type: InfoType.USER_TWAP_SLICE_FILLS,
191 |       user,
192 |     });
193 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
194 |   }
195 | 
196 |   async getSubAccounts(user: string, rawResponse: boolean = false): Promise<SubAccount[]> {
197 |     const response = await this.httpApi.makeRequest({
198 |       type: InfoType.SUB_ACCOUNTS,
199 |       user,
200 |     });
201 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
202 |   }
203 | 
204 |   async getVaultDetails(
205 |     vaultAddress: string,
206 |     user?: string,
207 |     rawResponse: boolean = false
208 |   ): Promise<VaultDetails> {
209 |     const params: any = {
210 |       type: InfoType.VAULT_DETAILS,
211 |       vaultAddress,
212 |     };
213 | 
214 |     if (user) {
215 |       params.user = user;
216 |     }
217 | 
218 |     const response = await this.httpApi.makeRequest(params);
219 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
220 |   }
221 | 
222 |   async getUserVaultEquities(user: string, rawResponse: boolean = false): Promise<VaultEquity[]> {
223 |     const response = await this.httpApi.makeRequest({
224 |       type: InfoType.USER_VAULT_EQUITIES,
225 |       user,
226 |     });
227 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
228 |   }
229 | 
230 |   async getUserRole(user: string, rawResponse: boolean = false): Promise<UserRole> {
231 |     const response = await this.httpApi.makeRequest({
232 |       type: InfoType.USER_ROLE,
233 |       user,
234 |     });
235 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
236 |   }
237 | 
238 |   async getDelegations(user: string, rawResponse: boolean = false): Promise<Delegation[]> {
239 |     const response = await this.httpApi.makeRequest({
240 |       type: InfoType.DELEGATIONS,
241 |       user,
242 |     });
243 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
244 |   }
245 | 
246 |   async getDelegatorSummary(user: string, rawResponse: boolean = false): Promise<DelegatorSummary> {
247 |     const response = await this.httpApi.makeRequest({
248 |       type: InfoType.DELEGATOR_SUMMARY,
249 |       user,
250 |     });
251 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
252 |   }
253 | 
254 |   async getDelegatorHistory(
255 |     user: string,
256 |     rawResponse: boolean = false
257 |   ): Promise<DelegatorHistoryEntry[]> {
258 |     const response = await this.httpApi.makeRequest({
259 |       type: InfoType.DELEGATOR_HISTORY,
260 |       user,
261 |     });
262 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
263 |   }
264 | 
265 |   async getDelegatorRewards(
266 |     user: string,
267 |     rawResponse: boolean = false
268 |   ): Promise<DelegatorReward[]> {
269 |     const response = await this.httpApi.makeRequest({
270 |       type: InfoType.DELEGATOR_REWARDS,
271 |       user,
272 |     });
273 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
274 |   }
275 | 
276 |   async validatorSummaries(rawResponse: boolean = false): Promise<ValidatorSummary[]> {
277 |     const response = await this.httpApi.makeRequest({
278 |       type: InfoType.VALIDATOR_SUMMARIES,
279 |     });
280 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
281 |   }
282 | 
283 |   async vaultSummaries(rawResponse: boolean = false): Promise<VaultSummary[]> {
284 |     const response = await this.httpApi.makeRequest({
285 |       type: InfoType.VAULT_SUMMARIES,
286 |     });
287 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
288 |   }
289 | 
290 |   async userFees(user: string, rawResponse: boolean = false): Promise<UserFees> {
291 |     const response = await this.httpApi.makeRequest({
292 |       type: InfoType.USER_FEES,
293 |       user,
294 |     });
295 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
296 |   }
297 | 
298 |   async portfolio(user: string, rawResponse: boolean = false): Promise<PortfolioPeriods> {
299 |     const response = await this.httpApi.makeRequest({
300 |       type: InfoType.PORTFOLIO,
301 |       user,
302 |     });
303 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
304 |   }
305 | 
306 |   async preTransferCheck(
307 |     user: string,
308 |     source: string,
309 |     rawResponse: boolean = false
310 |   ): Promise<PreTransferCheck> {
311 |     const response = await this.httpApi.makeRequest({
312 |       type: InfoType.PRE_TRANSFER_CHECK,
313 |       user,
314 |       source,
315 |     });
316 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
317 |   }
318 | 
319 |   async referral(user: string, rawResponse: boolean = false): Promise<Referral> {
320 |     const response = await this.httpApi.makeRequest({
321 |       type: InfoType.REFERRAL,
322 |       user,
323 |     });
324 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
325 |   }
326 | 
327 |   async extraAgents(user: string, rawResponse: boolean = false): Promise<ExtraAgent[]> {
328 |     const response = await this.httpApi.makeRequest({
329 |       type: InfoType.EXTRA_AGENTS,
330 |       user,
331 |     });
332 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
333 |   }
334 | 
335 |   async isVip(user: string, rawResponse: boolean = false): Promise<boolean> {
336 |     const response = await this.httpApi.makeRequest({
337 |       type: InfoType.IS_VIP,
338 |       user,
339 |     });
340 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
341 |   }
342 | 
343 |   async legalCheck(user: string, rawResponse: boolean = false): Promise<LegalCheck> {
344 |     const response = await this.httpApi.makeRequest({
345 |       type: InfoType.LEGAL_CHECK,
346 |       user,
347 |     });
348 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
349 |   }
350 | 
351 |   async userTwapSliceFillsByTime(
352 |     user: string,
353 |     startTime: number,
354 |     endTime?: number,
355 |     aggregateByTime?: boolean,
356 |     rawResponse: boolean = false
357 |   ): Promise<TwapSliceFill[]> {
358 |     const params: any = {
359 |       type: InfoType.USER_TWAP_SLICE_FILLS_BY_TIME,
360 |       user,
361 |       startTime,
362 |     };
363 | 
364 |     if (endTime !== undefined) params.endTime = endTime;
365 |     if (aggregateByTime !== undefined) params.aggregateByTime = aggregateByTime;
366 | 
367 |     const response = await this.httpApi.makeRequest(params);
368 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
369 |   }
370 | 
371 |   async twapHistory(user: string, rawResponse: boolean = false): Promise<TwapHistory[]> {
372 |     const response = await this.httpApi.makeRequest({
373 |       type: InfoType.TWAP_HISTORY,
374 |       user,
375 |     });
376 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
377 |   }
378 | 
379 |   async userToMultiSigSigners(
380 |     user: string,
381 |     rawResponse: boolean = false
382 |   ): Promise<MultiSigSigners | null> {
383 |     const response = await this.httpApi.makeRequest({
384 |       type: InfoType.USER_TO_MULTI_SIG_SIGNERS,
385 |       user,
386 |     });
387 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
388 |   }
389 | }
390 | 


--------------------------------------------------------------------------------
/src/rest/info/perpetuals.ts:
--------------------------------------------------------------------------------
  1 | import {
  2 |   Meta,
  3 |   MetaAndAssetCtxs,
  4 |   ClearinghouseState,
  5 |   UserFunding,
  6 |   UserNonFundingLedgerUpdates,
  7 |   FundingHistory,
  8 |   PredictedFundings,
  9 |   PerpsAtOpenInterestCap,
 10 | } from '../../types';
 11 | import { HttpApi } from '../../utils/helpers';
 12 | import { InfoType } from '../../types/constants';
 13 | import { SymbolConversion } from '../../utils/symbolConversion';
 14 | import { Hyperliquid } from '../../index';
 15 | 
 16 | export class PerpetualsInfoAPI {
 17 |   private httpApi: HttpApi;
 18 |   private symbolConversion: SymbolConversion;
 19 |   private parent: Hyperliquid;
 20 | 
 21 |   constructor(httpApi: HttpApi, symbolConversion: SymbolConversion, parent: Hyperliquid) {
 22 |     this.httpApi = httpApi;
 23 |     this.symbolConversion = symbolConversion;
 24 |     this.parent = parent;
 25 |   }
 26 | 
 27 |   async getMeta(rawResponse: boolean = false): Promise<Meta> {
 28 |     const response = await this.httpApi.makeRequest({ type: InfoType.META });
 29 |     return rawResponse
 30 |       ? response
 31 |       : await this.symbolConversion.convertResponse(response, ['name', 'coin', 'symbol'], 'PERP');
 32 |   }
 33 | 
 34 |   async getMetaAndAssetCtxs(rawResponse: boolean = false): Promise<MetaAndAssetCtxs> {
 35 |     const response = await this.httpApi.makeRequest({ type: InfoType.PERPS_META_AND_ASSET_CTXS });
 36 |     return rawResponse
 37 |       ? response
 38 |       : await this.symbolConversion.convertResponse(response, ['name', 'coin', 'symbol'], 'PERP');
 39 |   }
 40 | 
 41 |   async getClearinghouseState(
 42 |     user: string,
 43 |     rawResponse: boolean = false
 44 |   ): Promise<ClearinghouseState> {
 45 |     const response = await this.httpApi.makeRequest({
 46 |       type: InfoType.PERPS_CLEARINGHOUSE_STATE,
 47 |       user: user,
 48 |     });
 49 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
 50 |   }
 51 | 
 52 |   async getUserFunding(
 53 |     user: string,
 54 |     startTime: number,
 55 |     endTime?: number,
 56 |     rawResponse: boolean = false
 57 |   ): Promise<UserFunding> {
 58 |     const response = await this.httpApi.makeRequest(
 59 |       {
 60 |         type: InfoType.USER_FUNDING,
 61 |         user: user,
 62 |         startTime: startTime,
 63 |         endTime: endTime,
 64 |       },
 65 |       20
 66 |     );
 67 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
 68 |   }
 69 | 
 70 |   async getUserNonFundingLedgerUpdates(
 71 |     user: string,
 72 |     startTime: number,
 73 |     endTime?: number,
 74 |     rawResponse: boolean = false
 75 |   ): Promise<UserNonFundingLedgerUpdates> {
 76 |     const response = await this.httpApi.makeRequest(
 77 |       {
 78 |         type: InfoType.USER_NON_FUNDING_LEDGER_UPDATES,
 79 |         user: user,
 80 |         startTime: startTime,
 81 |         endTime: endTime,
 82 |       },
 83 |       20
 84 |     );
 85 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
 86 |   }
 87 | 
 88 |   async getFundingHistory(
 89 |     coin: string,
 90 |     startTime: number,
 91 |     endTime?: number,
 92 |     rawResponse: boolean = false
 93 |   ): Promise<FundingHistory> {
 94 |     await this.parent.ensureInitialized();
 95 |     const response = await this.httpApi.makeRequest(
 96 |       {
 97 |         type: InfoType.FUNDING_HISTORY,
 98 |         coin: await this.symbolConversion.convertSymbol(coin, 'reverse'),
 99 |         startTime: startTime,
100 |         endTime: endTime,
101 |       },
102 |       20
103 |     );
104 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
105 |   }
106 | 
107 |   async getPredictedFundings(rawResponse: boolean = false): Promise<PredictedFundings> {
108 |     const response = await this.httpApi.makeRequest(
109 |       {
110 |         type: InfoType.PREDICTED_FUNDINGS,
111 |       },
112 |       20
113 |     );
114 | 
115 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
116 |   }
117 | 
118 |   async getPerpsAtOpenInterestCap(rawResponse: boolean = false): Promise<PerpsAtOpenInterestCap> {
119 |     const response = (await this.httpApi.makeRequest({
120 |       type: InfoType.PERPS_AT_OPEN_INTEREST_CAP,
121 |     })) as string[];
122 | 
123 |     if (rawResponse) {
124 |       return response;
125 |     }
126 | 
127 |     // Convert each symbol in the array
128 |     const convertedResponse = await Promise.all(
129 |       response.map((symbol: string) => this.symbolConversion.convertSymbol(symbol, '', 'PERP'))
130 |     );
131 | 
132 |     return convertedResponse;
133 |   }
134 | }
135 | 


--------------------------------------------------------------------------------
/src/rest/info/spot.ts:
--------------------------------------------------------------------------------
 1 | import { SpotMeta, SpotClearinghouseState, SpotMetaAndAssetCtxs } from '../../types';
 2 | import { HttpApi } from '../../utils/helpers';
 3 | import { InfoType } from '../../types/constants';
 4 | import { SymbolConversion } from '../../utils/symbolConversion';
 5 | 
 6 | export class SpotInfoAPI {
 7 |   private httpApi: HttpApi;
 8 |   private symbolConversion: SymbolConversion;
 9 | 
10 |   constructor(httpApi: HttpApi, symbolConversion: SymbolConversion) {
11 |     this.httpApi = httpApi;
12 |     this.symbolConversion = symbolConversion;
13 |   }
14 | 
15 |   async getSpotMeta(rawResponse: boolean = false): Promise<SpotMeta> {
16 |     const response = await this.httpApi.makeRequest({ type: InfoType.SPOT_META });
17 |     return rawResponse
18 |       ? response
19 |       : await this.symbolConversion.convertResponse(response, ['name', 'coin', 'symbol'], 'SPOT');
20 |   }
21 | 
22 |   async getSpotClearinghouseState(
23 |     user: string,
24 |     rawResponse: boolean = false
25 |   ): Promise<SpotClearinghouseState> {
26 |     const response = await this.httpApi.makeRequest({
27 |       type: InfoType.SPOT_CLEARINGHOUSE_STATE,
28 |       user: user,
29 |     });
30 |     return rawResponse
31 |       ? response
32 |       : await this.symbolConversion.convertResponse(response, ['name', 'coin', 'symbol'], 'SPOT');
33 |   }
34 | 
35 |   async getSpotMetaAndAssetCtxs(rawResponse: boolean = false): Promise<SpotMetaAndAssetCtxs> {
36 |     const response = await this.httpApi.makeRequest({ type: InfoType.SPOT_META_AND_ASSET_CTXS });
37 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
38 |   }
39 | 
40 |   async getTokenDetails(tokenId: string, rawResponse: boolean = false): Promise<any> {
41 |     const response = await this.httpApi.makeRequest(
42 |       {
43 |         type: InfoType.TOKEN_DETAILS,
44 |         tokenId: tokenId,
45 |       },
46 |       20
47 |     );
48 | 
49 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
50 |   }
51 | 
52 |   async getSpotDeployState(user: string, rawResponse: boolean = false): Promise<any> {
53 |     const response = await this.httpApi.makeRequest(
54 |       {
55 |         type: InfoType.SPOT_DEPLOY_STATE,
56 |         user: user,
57 |       },
58 |       20
59 |     );
60 | 
61 |     return rawResponse ? response : await this.symbolConversion.convertResponse(response);
62 |   }
63 | }
64 | 


--------------------------------------------------------------------------------
/src/types/constants.ts:
--------------------------------------------------------------------------------
  1 | export const BASE_URLS = {
  2 |   PRODUCTION: 'https://api.hyperliquid.xyz',
  3 |   TESTNET: 'https://api.hyperliquid-testnet.xyz',
  4 | };
  5 | 
  6 | export const WSS_URLS = {
  7 |   PRODUCTION: 'wss://api.hyperliquid.xyz/ws',
  8 |   TESTNET: 'wss://api.hyperliquid-testnet.xyz/ws',
  9 | };
 10 | 
 11 | export const CHAIN_IDS = {
 12 |   ARBITRUM_MAINNET: '0xa4b1', // 42161
 13 |   ARBITRUM_TESTNET: '0x66eee', // 421614 - testnet//Arbitrum Sepolia
 14 | };
 15 | 
 16 | export const ENDPOINTS = {
 17 |   INFO: '/info',
 18 |   EXCHANGE: '/exchange',
 19 | };
 20 | 
 21 | export enum InfoType {
 22 |   ALL_MIDS = 'allMids',
 23 |   META = 'meta',
 24 |   OPEN_ORDERS = 'openOrders',
 25 |   FRONTEND_OPEN_ORDERS = 'frontendOpenOrders',
 26 |   USER_FILLS = 'userFills',
 27 |   USER_FILLS_BY_TIME = 'userFillsByTime',
 28 |   USER_RATE_LIMIT = 'userRateLimit',
 29 |   ORDER_STATUS = 'orderStatus',
 30 |   L2_BOOK = 'l2Book',
 31 |   CANDLE_SNAPSHOT = 'candleSnapshot',
 32 |   PERPS_META_AND_ASSET_CTXS = 'metaAndAssetCtxs',
 33 |   PERPS_CLEARINGHOUSE_STATE = 'clearinghouseState',
 34 |   USER_FUNDING = 'userFunding',
 35 |   USER_NON_FUNDING_LEDGER_UPDATES = 'userNonFundingLedgerUpdates',
 36 |   FUNDING_HISTORY = 'fundingHistory',
 37 |   SPOT_META = 'spotMeta',
 38 |   SPOT_CLEARINGHOUSE_STATE = 'spotClearinghouseState',
 39 |   SPOT_META_AND_ASSET_CTXS = 'spotMetaAndAssetCtxs',
 40 |   PREDICTED_FUNDINGS = 'predictedFundings',
 41 |   SPOT_DEPLOY_STATE = 'spotDeployState',
 42 |   TOKEN_DETAILS = 'tokenDetails',
 43 |   MAX_BUILDER_FEE = 'maxBuilderFee',
 44 |   HISTORICAL_ORDERS = 'historicalOrders',
 45 |   USER_TWAP_SLICE_FILLS = 'userTwapSliceFills',
 46 |   SUB_ACCOUNTS = 'subAccounts',
 47 |   VAULT_DETAILS = 'vaultDetails',
 48 |   USER_VAULT_EQUITIES = 'userVaultEquities',
 49 |   USER_ROLE = 'userRole',
 50 |   DELEGATIONS = 'delegations',
 51 |   DELEGATOR_SUMMARY = 'delegatorSummary',
 52 |   PERPS_AT_OPEN_INTEREST_CAP = 'perpsAtOpenInterestCap',
 53 |   DELEGATOR_HISTORY = 'delegatorHistory',
 54 |   DELEGATOR_REWARDS = 'delegatorRewards',
 55 |   VALIDATOR_SUMMARIES = 'validatorSummaries',
 56 |   VAULT_SUMMARIES = 'vaultSummaries',
 57 |   BLOCK_DETAILS = 'blockDetails',
 58 |   TX_DETAILS = 'txDetails',
 59 |   USER_DETAILS = 'userDetails',
 60 |   USER_FEES = 'userFees',
 61 |   PORTFOLIO = 'portfolio',
 62 |   PRE_TRANSFER_CHECK = 'preTransferCheck',
 63 |   REFERRAL = 'referral',
 64 |   EXTRA_AGENTS = 'extraAgents',
 65 |   IS_VIP = 'isVip',
 66 |   LEGAL_CHECK = 'legalCheck',
 67 |   USER_TWAP_SLICE_FILLS_BY_TIME = 'userTwapSliceFillsByTime',
 68 |   TWAP_HISTORY = 'twapHistory',
 69 |   USER_TO_MULTI_SIG_SIGNERS = 'userToMultiSigSigners',
 70 | }
 71 | 
 72 | export enum ExchangeType {
 73 |   ORDER = 'order',
 74 |   CANCEL = 'cancel',
 75 |   CANCEL_BY_CLOID = 'cancelByCloid',
 76 |   SCHEDULE_CANCEL = 'scheduleCancel',
 77 |   MODIFY = 'modify',
 78 |   BATCH_MODIFY = 'batchModify',
 79 |   UPDATE_LEVERAGE = 'updateLeverage',
 80 |   UPDATE_ISOLATED_MARGIN = 'updateIsolatedMargin',
 81 |   USD_SEND = 'usdSend',
 82 |   SPOT_SEND = 'spotSend',
 83 |   WITHDRAW = 'withdraw3',
 84 |   SPOT_USER = 'spotUser',
 85 |   VAULT_TRANSFER = 'vaultTransfer',
 86 |   CREATE_VAULT = 'createVault',
 87 |   VAULT_DISTRIBUTE = 'vaultDistribute',
 88 |   VAULT_MODIFY = 'vaultModify',
 89 |   SET_REFERRER = 'setReferrer',
 90 |   USD_CLASS_TRANSFER = 'usdClassTransfer',
 91 |   TWAP_ORDER = 'twapOrder',
 92 |   TWAP_CANCEL = 'twapCancel',
 93 |   APPROVE_AGENT = 'approveAgent',
 94 |   APPROVE_BUILDER_FEE = 'approveBuilderFee',
 95 |   EVM_USER_MODIFY = 'evmUserModify',
 96 |   CLAIM_REWARDS = 'claimRewards',
 97 |   CREATE_SUB_ACCOUNT = 'createSubAccount',
 98 |   SET_DISPLAY_NAME = 'setDisplayName',
 99 |   C_DEPOSIT = 'cDeposit',
100 |   C_WITHDRAW = 'cWithdraw',
101 |   TOKEN_DELEGATE = 'tokenDelegate',
102 |   SUB_ACCOUNT_SPOT_TRANSFER = 'subAccountSpotTransfer',
103 |   SUB_ACCOUNT_TRANSFER = 'subAccountTransfer',
104 |   RESERVE_REQUEST_WEIGHT = 'reserveRequestWeight',
105 | }
106 | 
107 | export const WEBSOCKET = {
108 |   MAINNET_URL: 'wss://api.hyperliquid.xyz/ws',
109 |   TESTNET_URL: 'wss://api.hyperliquid-testnet.xyz/ws',
110 | };
111 | 
112 | export const SDK_CODE = 'PLACEHOLDER';
113 | 


--------------------------------------------------------------------------------
/src/types/index.ts:
--------------------------------------------------------------------------------
   1 | export type Tif = 'Alo' | 'Ioc' | 'Gtc';
   2 | export type TriggerType = 'tp' | 'sl';
   3 | export type LimitOrder = { tif: Tif };
   4 | export type TriggerOrder = { triggerPx: string | number; isMarket: boolean; tpsl: TriggerType };
   5 | export type Grouping = 'na' | 'normalTpsl' | 'positionTpsl';
   6 | export type OrderType = { limit?: LimitOrder; trigger?: TriggerOrder };
   7 | export type Cloid = string;
   8 | export type OidOrCloid = number | Cloid;
   9 | 
  10 | export interface OrderRequest {
  11 |   coin: string;
  12 |   is_buy: boolean;
  13 |   sz: number | string;
  14 |   limit_px: number | string;
  15 |   order_type: OrderType;
  16 |   reduce_only: boolean;
  17 |   cloid?: string;
  18 |   grouping?: Grouping;
  19 |   builder?: Builder;
  20 | }
  21 | 
  22 | interface BaseOrder {
  23 |   vaultAddress?: string;
  24 |   grouping?: Grouping;
  25 |   builder?: Builder;
  26 | }
  27 | 
  28 | export interface Order extends BaseOrder {
  29 |   coin: string;
  30 |   is_buy: boolean;
  31 |   sz: number | string;
  32 |   limit_px: number | string;
  33 |   order_type: OrderType;
  34 |   reduce_only: boolean;
  35 |   cloid?: Cloid;
  36 |   orders?: undefined;
  37 | }
  38 | 
  39 | export interface MultiOrder extends BaseOrder {
  40 |   orders: OrderRequest[];
  41 | }
  42 | 
  43 | export type BulkOrderRequest = MultiOrder;
  44 | 
  45 | export interface Builder {
  46 |   address: string;
  47 |   fee: number;
  48 | }
  49 | 
  50 | export interface AllMids {
  51 |   [coin: string]: string;
  52 | }
  53 | 
  54 | export type Meta = {
  55 |   universe: {
  56 |     name: string;
  57 |     szDecimals: number;
  58 |     maxLeverage: number;
  59 |     onlyIsolated?: boolean;
  60 |   }[];
  61 | };
  62 | 
  63 | export interface ClearinghouseState {
  64 |   assetPositions: {
  65 |     position: {
  66 |       coin: string;
  67 |       cumFunding: {
  68 |         allTime: string;
  69 |         sinceChange: string;
  70 |         sinceOpen: string;
  71 |       };
  72 |       entryPx: string;
  73 |       leverage: {
  74 |         rawUsd: string;
  75 |         type: string;
  76 |         value: number;
  77 |       };
  78 |       liquidationPx: string;
  79 |       marginUsed: string;
  80 |       maxLeverage: number;
  81 |       positionValue: string;
  82 |       returnOnEquity: string;
  83 |       szi: string;
  84 |       unrealizedPnl: string;
  85 |     };
  86 |     type: string;
  87 |   }[];
  88 |   crossMaintenanceMarginUsed: string;
  89 |   crossMarginSummary: {
  90 |     accountValue: string;
  91 |     totalMarginUsed: string;
  92 |     totalNtlPos: string;
  93 |     totalRawUsd: string;
  94 |   };
  95 |   marginSummary: {
  96 |     accountValue: string;
  97 |     totalMarginUsed: string;
  98 |     totalNtlPos: string;
  99 |     totalRawUsd: string;
 100 |   };
 101 |   time: number;
 102 |   withdrawable: string;
 103 | }
 104 | 
 105 | export type UserFills = {
 106 |   closedPnl: string;
 107 |   coin: string;
 108 |   crossed: boolean;
 109 |   dir: string;
 110 |   hash: string;
 111 |   oid: number;
 112 |   px: string;
 113 |   side: string;
 114 |   startPosition: string;
 115 |   sz: string;
 116 |   time: number;
 117 | }[];
 118 | 
 119 | export interface OrderResponse {
 120 |   status: string;
 121 |   response: {
 122 |     type: string;
 123 |     data: {
 124 |       statuses: Array<{
 125 |         resting?: { oid: number };
 126 |         filled?: {
 127 |           oid: number;
 128 |           totalSz: string;
 129 |           avgPx: string;
 130 |         };
 131 |       }>;
 132 |     };
 133 |   };
 134 | }
 135 | 
 136 | export interface Leverage {
 137 |   type: 'cross' | 'isolated';
 138 |   value: number;
 139 |   rawUsd?: string;
 140 | }
 141 | 
 142 | export interface WsTrade {
 143 |   coin: string;
 144 |   side: string;
 145 |   px: string;
 146 |   sz: string;
 147 |   hash: string;
 148 |   time: number;
 149 |   tid: number;
 150 | }
 151 | 
 152 | export interface WsBook {
 153 |   coin: string;
 154 |   levels: [Array<WsLevel>, Array<WsLevel>];
 155 |   time: number;
 156 | }
 157 | 
 158 | export interface WsBbo {
 159 |   coin: string;
 160 |   time: number;
 161 |   bbo: [WsLevel | null, WsLevel | null];
 162 | }
 163 | 
 164 | export interface WsLevel {
 165 |   px: string;
 166 |   sz: string;
 167 |   n: number;
 168 | }
 169 | 
 170 | export interface WsOrder {
 171 |   order: {
 172 |     coin: string;
 173 |     side: string;
 174 |     limitPx: string;
 175 |     sz: string;
 176 |     oid: number;
 177 |     timestamp: number;
 178 |     origSz: string;
 179 |   };
 180 |   status: string;
 181 |   statusTimestamp: number;
 182 |   user: string;
 183 | }
 184 | 
 185 | export type WsUserEvent = (WsFill[] | WsUserFunding | WsLiquidation | WsNonUserCancel[]) & {
 186 |   user: string;
 187 | };
 188 | 
 189 | export interface WsFill {
 190 |   coin: string;
 191 |   px: string;
 192 |   sz: string;
 193 |   side: string;
 194 |   time: number;
 195 |   startPosition: string;
 196 |   dir: string;
 197 |   closedPnl: string;
 198 |   hash: string;
 199 |   oid: number;
 200 |   crossed: boolean;
 201 |   fee: string;
 202 |   tid: number;
 203 | }
 204 | 
 205 | export interface WsUserFunding {
 206 |   time: number;
 207 |   coin: string;
 208 |   usdc: string;
 209 |   szi: string;
 210 |   fundingRate: string;
 211 | }
 212 | 
 213 | export interface WsLiquidation {
 214 |   lid: number;
 215 |   liquidator: string;
 216 |   liquidated_user: string;
 217 |   liquidated_ntl_pos: string;
 218 |   liquidated_account_value: string;
 219 | }
 220 | 
 221 | export interface WsNonUserCancel {
 222 |   coin: string;
 223 |   oid: number;
 224 | }
 225 | 
 226 | export interface SpotClearinghouseState {
 227 |   balances: {
 228 |     coin: string;
 229 |     hold: string;
 230 |     total: string;
 231 |   }[];
 232 | }
 233 | 
 234 | export type FrontendOpenOrders = {
 235 |   coin: string;
 236 |   isPositionTpsl: boolean;
 237 |   isTrigger: boolean;
 238 |   limitPx: string;
 239 |   oid: number;
 240 |   orderType: string;
 241 |   origSz: string;
 242 |   reduceOnly: boolean;
 243 |   side: string;
 244 |   sz: string;
 245 |   timestamp: number;
 246 |   triggerCondition: string;
 247 |   triggerPx: string;
 248 | }[];
 249 | 
 250 | export interface UserRateLimit {
 251 |   [key: string]: any;
 252 | }
 253 | 
 254 | export interface OrderStatus {
 255 |   [key: string]: any;
 256 | }
 257 | 
 258 | export interface L2Book {
 259 |   levels: [
 260 |     {
 261 |       px: string;
 262 |       sz: string;
 263 |       n: number;
 264 |     }[],
 265 |     {
 266 |       px: string;
 267 |       sz: string;
 268 |       n: number;
 269 |     }[],
 270 |   ];
 271 | }
 272 | 
 273 | export type CandleSnapshot = {
 274 |   T: number;
 275 |   c: string;
 276 |   h: string;
 277 |   i: string;
 278 |   l: string;
 279 |   n: number;
 280 |   o: string;
 281 |   s: string;
 282 |   t: number;
 283 |   v: string;
 284 | }[];
 285 | 
 286 | export type AssetCtx = {
 287 |   dayBaseVlm: string;
 288 |   dayNtlVlm: string;
 289 |   funding: string;
 290 |   impactPxs: [string, string];
 291 |   markPx: string;
 292 |   midPx: string;
 293 |   openInterest: string;
 294 |   oraclePx: string;
 295 |   premium: string;
 296 |   prevDayPx: string;
 297 | };
 298 | 
 299 | export type MetaAndAssetCtxs = [Meta, AssetCtx[]];
 300 | 
 301 | export interface UserFundingDelta {
 302 |   coin: string;
 303 |   fundingRate: string;
 304 |   szi: string;
 305 |   type: 'funding';
 306 |   usdc: string;
 307 | }
 308 | 
 309 | export interface UserFundingEntry {
 310 |   delta: UserFundingDelta;
 311 |   hash: string;
 312 |   time: number;
 313 | }
 314 | 
 315 | export type UserFunding = UserFundingEntry[];
 316 | 
 317 | export interface UserNonFundingLedgerDelta {
 318 |   coin: string;
 319 |   type: 'deposit' | 'withdraw' | 'transfer' | 'liquidation';
 320 |   usdc: string;
 321 | }
 322 | 
 323 | export interface UserNonFundingLedgerEntry {
 324 |   delta: UserNonFundingLedgerDelta;
 325 |   hash: string;
 326 |   time: number;
 327 | }
 328 | 
 329 | export type UserNonFundingLedgerUpdates = UserNonFundingLedgerEntry[];
 330 | 
 331 | export interface FundingHistoryEntry {
 332 |   coin: string;
 333 |   fundingRate: string;
 334 |   premium: string;
 335 |   time: number;
 336 | }
 337 | 
 338 | export type FundingHistory = FundingHistoryEntry[];
 339 | 
 340 | export interface SpotToken {
 341 |   name: string;
 342 |   szDecimals: number;
 343 |   weiDecimals: number;
 344 |   index: number;
 345 |   tokenId: string;
 346 |   isCanonical: boolean;
 347 | }
 348 | 
 349 | export interface SpotMarket {
 350 |   name: string;
 351 |   tokens: [number, number]; // Indices of base and quote tokens
 352 |   index: number;
 353 |   isCanonical: boolean;
 354 | }
 355 | 
 356 | export type SpotMeta = {
 357 |   tokens: SpotToken[];
 358 |   universe: SpotMarket[];
 359 | };
 360 | 
 361 | export type SpotAssetCtx = {
 362 |   circulatingSupply: string;
 363 |   coin: string;
 364 |   dayBaseVlm: string;
 365 |   dayNtlVlm: string;
 366 |   markPx: string;
 367 |   midPx: string;
 368 |   prevDayPx: string;
 369 |   totalSupply: string;
 370 | };
 371 | 
 372 | export type SpotMetaAndAssetCtxs = [SpotMeta, SpotAssetCtx[]];
 373 | 
 374 | export interface UserOpenOrder {
 375 |   coin: string;
 376 |   limitPx: string;
 377 |   oid: number;
 378 |   side: string;
 379 |   sz: string;
 380 |   timestamp: number;
 381 | }
 382 | 
 383 | export type UserOpenOrders = UserOpenOrder[];
 384 | 
 385 | export interface OrderWire {
 386 |   a: number;
 387 |   b: boolean;
 388 |   p: string;
 389 |   s: string;
 390 |   r: boolean;
 391 |   t: OrderType;
 392 |   c?: string;
 393 | }
 394 | 
 395 | export interface CancelOrderRequest {
 396 |   coin: string;
 397 |   o: number;
 398 | }
 399 | 
 400 | export type CancelOrderRequests = {
 401 |   a: number;
 402 |   o: number;
 403 | }[];
 404 | 
 405 | export interface CancelByCloidRequest {
 406 |   coin: string;
 407 |   cloid: Cloid;
 408 | }
 409 | 
 410 | export interface ModifyRequest {
 411 |   oid: OidOrCloid;
 412 |   order: OrderRequest;
 413 | }
 414 | 
 415 | export interface ModifyWire {
 416 |   oid: number;
 417 |   order: OrderWire;
 418 | }
 419 | 
 420 | export interface ScheduleCancelAction {
 421 |   type: 'scheduleCancel';
 422 |   time?: number | null;
 423 | }
 424 | 
 425 | export interface Signature {
 426 |   r: string;
 427 |   s: string;
 428 |   v: number;
 429 | }
 430 | 
 431 | export interface Notification {
 432 |   notification: string;
 433 |   user: string;
 434 | }
 435 | 
 436 | // As flexible as possible
 437 | export interface WebData2 {
 438 |   [key: string]: any;
 439 | }
 440 | 
 441 | export interface Candle {
 442 |   t: number; // open time
 443 |   T: number; // close time
 444 |   s: string; // symbol
 445 |   i: string; // interval
 446 |   o: string; // open
 447 |   c: string; // close
 448 |   h: string; // high
 449 |   l: string; // low
 450 |   v: string; // volume
 451 |   n: number; // number of trades
 452 |   coin: string;
 453 |   interval: string;
 454 | }
 455 | 
 456 | export interface WsUserFill {
 457 |   coin: string;
 458 |   px: string;
 459 |   sz: string;
 460 |   side: string;
 461 |   time: number;
 462 |   startPosition: string;
 463 |   dir: string;
 464 |   closedPnl: string;
 465 |   hash: string;
 466 |   oid: number;
 467 |   crossed: boolean;
 468 |   fee: string;
 469 |   tid: number;
 470 | }
 471 | 
 472 | export type WsUserFills = {
 473 |   isSnapshot: boolean;
 474 |   fills: WsUserFill[];
 475 |   user: string;
 476 | };
 477 | 
 478 | export interface WsUserFunding {
 479 |   time: number;
 480 |   coin: string;
 481 |   usdc: string;
 482 |   szi: string;
 483 |   fundingRate: string;
 484 | }
 485 | 
 486 | export type WsUserFundings = {
 487 |   isSnapshot: boolean;
 488 |   fundings: WsUserFunding[];
 489 |   user: string;
 490 | };
 491 | 
 492 | export interface WsUserNonFundingLedgerUpdate {
 493 |   time: number;
 494 |   coin: string;
 495 |   usdc: string;
 496 |   type: 'deposit' | 'withdraw' | 'transfer' | 'liquidation';
 497 | }
 498 | 
 499 | export type WsUserNonFundingLedgerUpdates = {
 500 |   isSnapshot: boolean;
 501 |   updates: WsUserNonFundingLedgerUpdate[];
 502 |   user: string;
 503 | };
 504 | 
 505 | export type WsUserActiveAssetData = {
 506 |   isSnapshot: boolean;
 507 |   user: string;
 508 |   coin: string;
 509 |   leverage: Leverage;
 510 |   maxTradeSzs: [number, number];
 511 |   availableToTrade: [number, number];
 512 | };
 513 | 
 514 | export interface TwapOrder {
 515 |   coin: string;
 516 |   is_buy: boolean;
 517 |   sz: number;
 518 |   reduce_only: boolean;
 519 |   minutes: number;
 520 |   randomize: boolean;
 521 | }
 522 | 
 523 | export interface TwapCancelRequest {
 524 |   coin: string;
 525 |   twap_id: number;
 526 | }
 527 | 
 528 | export interface TwapOrderResponse {
 529 |   status: string;
 530 |   response: {
 531 |     type: string;
 532 |     data: {
 533 |       status: {
 534 |         running: {
 535 |           twapId: number;
 536 |         };
 537 |       };
 538 |     };
 539 |   };
 540 | }
 541 | 
 542 | export interface TwapCancelResponse {
 543 |   status: string;
 544 |   response: {
 545 |     type: string;
 546 |     data: {
 547 |       status: string;
 548 |     };
 549 |   };
 550 | }
 551 | 
 552 | export interface PredictedFunding {
 553 |   fundingRate: string;
 554 |   nextFundingTime: number;
 555 | }
 556 | 
 557 | export interface VenueFunding {
 558 |   [venue: string]: PredictedFunding;
 559 | }
 560 | 
 561 | export interface PredictedFundings {
 562 |   [coin: string]: VenueFunding[];
 563 | }
 564 | 
 565 | export interface TokenDetails {
 566 |   name: string;
 567 |   maxSupply: string;
 568 |   totalSupply: string;
 569 |   circulatingSupply: string;
 570 |   szDecimals: number;
 571 |   weiDecimals: number;
 572 |   midPx: string;
 573 |   markPx: string;
 574 |   prevDayPx: string;
 575 |   genesis: {
 576 |     userBalances: [string, string][];
 577 |     existingTokenBalances: [number, string][];
 578 |   };
 579 |   deployer: string;
 580 |   deployGas: string;
 581 |   deployTime: string;
 582 |   seededUsdc: string;
 583 |   nonCirculatingUserBalances: string[];
 584 |   futureEmissions: string;
 585 | }
 586 | 
 587 | export interface SpotDeployState {
 588 |   states: {
 589 |     token: number;
 590 |     spec: {
 591 |       name: string;
 592 |       szDecimals: number;
 593 |       weiDecimals: number;
 594 |     };
 595 |     fullName: string;
 596 |     spots: number[];
 597 |     maxSupply: number;
 598 |     hyperliquidityGenesisBalance: string;
 599 |     totalGenesisBalanceWei: string;
 600 |     userGenesisBalances: [string, string][];
 601 |     existingTokenGenesisBalances: [number, string][];
 602 |   }[];
 603 |   gasAuction: {
 604 |     startTimeSeconds: number;
 605 |     durationSeconds: number;
 606 |     startGas: string;
 607 |     currentGas: string | null;
 608 |     endGas: string;
 609 |   };
 610 | }
 611 | 
 612 | export interface SubAccount {
 613 |   name: string;
 614 |   subAccountUser: string;
 615 |   master: string;
 616 |   clearinghouseState: ClearinghouseState;
 617 |   spotState: {
 618 |     balances: {
 619 |       coin: string;
 620 |       token: number;
 621 |       total: string;
 622 |       hold: string;
 623 |       entryNtl: string;
 624 |     }[];
 625 |   };
 626 | }
 627 | 
 628 | export interface PortfolioPeriodData {
 629 |   accountValueHistory: [number, string][];
 630 |   pnlHistory: [number, string][];
 631 |   vlm: string;
 632 | }
 633 | 
 634 | export interface VaultFollower {
 635 |   user: string;
 636 |   vaultEquity: string;
 637 |   pnl: string;
 638 |   allTimePnl: string;
 639 |   daysFollowing: number;
 640 |   vaultEntryTime: number;
 641 |   lockupUntil: number;
 642 | }
 643 | 
 644 | export interface VaultDetails {
 645 |   name: string;
 646 |   vaultAddress: string;
 647 |   leader: string;
 648 |   description: string;
 649 |   portfolio: [string, PortfolioPeriodData][];
 650 |   apr: number;
 651 |   followerState: any;
 652 |   leaderFraction: number;
 653 |   leaderCommission: number;
 654 |   followers: VaultFollower[];
 655 |   maxDistributable: number;
 656 |   maxWithdrawable: number;
 657 |   isClosed: boolean;
 658 |   relationship: {
 659 |     type: string;
 660 |     data: {
 661 |       childAddresses: string[];
 662 |     };
 663 |   };
 664 |   allowDeposits: boolean;
 665 |   alwaysCloseOnWithdraw: boolean;
 666 | }
 667 | 
 668 | export interface VaultEquity {
 669 |   vaultAddress: string;
 670 |   equity: string;
 671 | }
 672 | 
 673 | export interface HistoricalOrder {
 674 |   order: {
 675 |     coin: string;
 676 |     side: string;
 677 |     limitPx: string;
 678 |     sz: string;
 679 |     oid: number;
 680 |     timestamp: number;
 681 |     triggerCondition: string;
 682 |     isTrigger: boolean;
 683 |     triggerPx: string;
 684 |     children: any[];
 685 |     isPositionTpsl: boolean;
 686 |     reduceOnly: boolean;
 687 |     orderType: string;
 688 |     origSz: string;
 689 |     tif: string;
 690 |     cloid: string | null;
 691 |   };
 692 |   status: 'filled' | 'open' | 'canceled' | 'triggered' | 'rejected' | 'marginCanceled';
 693 |   statusTimestamp: number;
 694 | }
 695 | 
 696 | export interface TwapSliceFill {
 697 |   fill: {
 698 |     closedPnl: string;
 699 |     coin: string;
 700 |     crossed: boolean;
 701 |     dir: string;
 702 |     hash: string;
 703 |     oid: number;
 704 |     px: string;
 705 |     side: string;
 706 |     startPosition: string;
 707 |     sz: string;
 708 |     time: number;
 709 |     fee: string;
 710 |     feeToken: string;
 711 |     tid: number;
 712 |   };
 713 |   twapId: number;
 714 | }
 715 | 
 716 | export interface ApproveAgentRequest {
 717 |   agentAddress: string;
 718 |   agentName?: string;
 719 | }
 720 | 
 721 | export interface ApproveBuilderFeeRequest {
 722 |   maxFeeRate: string;
 723 |   builder: string;
 724 | }
 725 | 
 726 | export interface Delegation {
 727 |   validator: string;
 728 |   amount: string;
 729 |   lockedUntilTimestamp: number;
 730 | }
 731 | 
 732 | export interface DelegatorSummary {
 733 |   delegated: string;
 734 |   undelegated: string;
 735 |   totalPendingWithdrawal: string;
 736 |   nPendingWithdrawals: number;
 737 | }
 738 | 
 739 | export interface DelegatorHistoryEntry {
 740 |   time: number;
 741 |   hash: string;
 742 |   delta: {
 743 |     delegate: {
 744 |       validator: string;
 745 |       amount: string;
 746 |       isUndelegate: boolean;
 747 |     };
 748 |   };
 749 | }
 750 | 
 751 | export interface DelegatorReward {
 752 |   time: number;
 753 |   source: string;
 754 |   totalAmount: string;
 755 | }
 756 | 
 757 | export type PerpsAtOpenInterestCap = string[];
 758 | 
 759 | export type UserRole = 'missing' | 'user' | 'agent' | 'vault' | 'subAccount';
 760 | 
 761 | export interface WsActiveAssetCtx {
 762 |   coin: string;
 763 |   ctx: {
 764 |     dayNtlVlm: string;
 765 |     prevDayPx: string;
 766 |     markPx: string;
 767 |     midPx?: string;
 768 |     funding?: number;
 769 |     openInterest?: number;
 770 |     oraclePx?: number;
 771 |     circulatingSupply?: number;
 772 |   };
 773 | }
 774 | 
 775 | export interface WsActiveSpotAssetCtx {
 776 |   coin: string;
 777 |   ctx: {
 778 |     dayNtlVlm: string;
 779 |     prevDayPx: string;
 780 |     markPx: string;
 781 |     midPx?: string;
 782 |     circulatingSupply: string;
 783 |   };
 784 | }
 785 | 
 786 | export interface WsTwapState {
 787 |   coin: string;
 788 |   user: string;
 789 |   side: string;
 790 |   sz: number;
 791 |   executedSz: number;
 792 |   executedNtl: number;
 793 |   minutes: number;
 794 |   reduceOnly: boolean;
 795 |   randomize: boolean;
 796 |   timestamp: number;
 797 | }
 798 | 
 799 | export type WsTwapStatus = 'activated' | 'terminated' | 'finished' | 'error';
 800 | 
 801 | export interface WsTwapHistory {
 802 |   state: WsTwapState;
 803 |   status: {
 804 |     status: WsTwapStatus;
 805 |     description: string;
 806 |   };
 807 |   time: number;
 808 | }
 809 | 
 810 | export interface WsTwapHistoryResponse {
 811 |   isSnapshot: boolean;
 812 |   user: string;
 813 |   history: WsTwapHistory[];
 814 | }
 815 | 
 816 | export interface WsTwapSliceFill {
 817 |   isSnapshot?: boolean;
 818 |   user: string;
 819 |   twapSliceFills: Array<{
 820 |     fill: {
 821 |       closedPnl: string;
 822 |       coin: string;
 823 |       crossed: boolean;
 824 |       dir: string;
 825 |       hash: string;
 826 |       oid: number;
 827 |       px: string;
 828 |       side: string;
 829 |       startPosition: string;
 830 |       sz: string;
 831 |       time: number;
 832 |       fee: string;
 833 |       feeToken: string;
 834 |       tid: number;
 835 |     };
 836 |     twapId: number;
 837 |   }>;
 838 | }
 839 | 
 840 | export interface ValidatorStats {
 841 |   uptimeFraction: string;
 842 |   predictedApr: string;
 843 |   nSamples: number;
 844 | }
 845 | 
 846 | export interface ValidatorSummary {
 847 |   validator: string;
 848 |   signer: string;
 849 |   name: string;
 850 |   description: string;
 851 |   nRecentBlocks: number;
 852 |   stake: number;
 853 |   isJailed: boolean;
 854 |   unjailableAfter: number | null;
 855 |   isActive: boolean;
 856 |   commission: string;
 857 |   stats: [['day', ValidatorStats], ['week', ValidatorStats], ['month', ValidatorStats]];
 858 | }
 859 | 
 860 | export interface VaultRelationship {
 861 |   type: 'normal' | 'child' | 'parent';
 862 |   data?: {
 863 |     childAddresses: string[];
 864 |   };
 865 | }
 866 | 
 867 | export interface VaultSummary {
 868 |   name: string;
 869 |   vaultAddress: string;
 870 |   leader: string;
 871 |   tvl: string;
 872 |   isClosed: boolean;
 873 |   relationship: VaultRelationship;
 874 |   createTimeMillis: number;
 875 | }
 876 | 
 877 | export interface TxDetails {
 878 |   action: {
 879 |     type: string;
 880 |     [key: string]: unknown;
 881 |   };
 882 |   block: number;
 883 |   error: string | null;
 884 |   hash: string;
 885 |   time: number;
 886 |   user: string;
 887 | }
 888 | 
 889 | export interface BlockDetails {
 890 |   blockTime: number;
 891 |   hash: string;
 892 |   height: number;
 893 |   numTxs: number;
 894 |   proposer: string;
 895 |   txs: TxDetails[];
 896 | }
 897 | 
 898 | export interface BlockDetailsResponse {
 899 |   type: 'blockDetails';
 900 |   blockDetails: BlockDetails;
 901 | }
 902 | 
 903 | export interface TxDetailsResponse {
 904 |   type: 'txDetails';
 905 |   tx: TxDetails;
 906 | }
 907 | 
 908 | export interface UserDetailsResponse {
 909 |   type: 'userDetails';
 910 |   txs: TxDetails[];
 911 | }
 912 | 
 913 | export interface UserFees {
 914 |   dailyUserVlm: {
 915 |     date: string;
 916 |     userCross: string;
 917 |     userAdd: string;
 918 |     exchange: string;
 919 |   }[];
 920 |   feeSchedule: {
 921 |     cross: string;
 922 |     add: string;
 923 |     tiers: {
 924 |       vip: {
 925 |         ntlCutoff: string;
 926 |         cross: string;
 927 |         add: string;
 928 |       }[];
 929 |       mm: {
 930 |         makerFractionCutoff: string;
 931 |         add: string;
 932 |       }[];
 933 |     };
 934 |     referralDiscount: string;
 935 |   };
 936 |   userCrossRate: string;
 937 |   userAddRate: string;
 938 |   activeReferralDiscount: string;
 939 |   trial: unknown | null;
 940 |   feeTrialReward: string;
 941 |   nextTrialAvailableTimestamp: unknown | null;
 942 | }
 943 | 
 944 | export interface Portfolio {
 945 |   accountValueHistory: [number, string][];
 946 |   pnlHistory: [number, string][];
 947 |   vlm: string;
 948 | }
 949 | 
 950 | export type PortfolioPeriods = [
 951 |   ['day', Portfolio],
 952 |   ['week', Portfolio],
 953 |   ['month', Portfolio],
 954 |   ['allTime', Portfolio],
 955 |   ['perpDay', Portfolio],
 956 |   ['perpWeek', Portfolio],
 957 |   ['perpMonth', Portfolio],
 958 |   ['perpAllTime', Portfolio],
 959 | ];
 960 | 
 961 | export interface PreTransferCheck {
 962 |   fee: string;
 963 |   isSanctioned: boolean;
 964 |   userExists: boolean;
 965 | }
 966 | 
 967 | export interface Referral {
 968 |   referredBy: {
 969 |     referrer: string;
 970 |     code: string;
 971 |   } | null;
 972 |   cumVlm: string;
 973 |   unclaimedRewards: string;
 974 |   claimedRewards: string;
 975 |   builderRewards: string;
 976 |   referrerState: {
 977 |     stage: 'ready' | 'needToCreateCode' | 'needToTrade';
 978 |     data?: {
 979 |       code?: string;
 980 |       referralStates?: {
 981 |         cumVlm: string;
 982 |         cumRewardedFeesSinceReferred: string;
 983 |         cumFeesRewardedToReferrer: string;
 984 |         timeJoined: number;
 985 |         user: string;
 986 |       }[];
 987 |       required?: string;
 988 |     };
 989 |   };
 990 |   rewardHistory: {
 991 |     earned: string;
 992 |     vlm: string;
 993 |     referralVlm: string;
 994 |     time: number;
 995 |   }[];
 996 | }
 997 | 
 998 | export interface ExtraAgent {
 999 |   address: string;
1000 |   name: string;
1001 |   validUntil: number;
1002 | }
1003 | 
1004 | export interface LegalCheck {
1005 |   ipAllowed: boolean;
1006 |   acceptedTerms: boolean;
1007 |   userAllowed: boolean;
1008 | }
1009 | 
1010 | export interface TwapState {
1011 |   coin: string;
1012 |   executedNtl: string;
1013 |   executedSz: string;
1014 |   minutes: number;
1015 |   randomize: boolean;
1016 |   reduceOnly: boolean;
1017 |   side: 'B' | 'A';
1018 |   sz: string;
1019 |   timestamp: number;
1020 |   user: string;
1021 | }
1022 | 
1023 | export interface TwapStatus {
1024 |   status: 'finished' | 'activated' | 'terminated' | 'error';
1025 |   description?: string;
1026 | }
1027 | 
1028 | export interface TwapHistory {
1029 |   time: number;
1030 |   state: TwapState;
1031 |   status: TwapStatus;
1032 | }
1033 | 
1034 | export interface MultiSigSigners {
1035 |   authorizedUsers: string[];
1036 |   threshold: number;
1037 | }
1038 | 
1039 | // Vault-related types
1040 | export interface CreateVaultRequest {
1041 |   name: string;
1042 |   description: string;
1043 |   initialUsd: number;
1044 | }
1045 | 
1046 | export interface CreateVaultResponse {
1047 |   status: string;
1048 |   response: {
1049 |     type: string;
1050 |     data: string; // Vault address
1051 |   };
1052 | }
1053 | 
1054 | export interface VaultDistributeRequest {
1055 |   vaultAddress: string;
1056 |   usd: number;
1057 | }
1058 | 
1059 | export interface VaultModifyRequest {
1060 |   vaultAddress: string;
1061 |   allowDeposits: boolean | null;
1062 |   alwaysCloseOnWithdraw: boolean | null;
1063 | }
1064 | 
1065 | // Response types
1066 | export interface ClaimRewardsResponse {
1067 |   status: string;
1068 |   response: {
1069 |     type: string;
1070 |   };
1071 | }
1072 | 
1073 | export interface CreateSubAccountResponse {
1074 |   status: string;
1075 |   response: {
1076 |     type: string;
1077 |     data: string; // Sub-account address
1078 |   };
1079 | }
1080 | 
1081 | export interface SetDisplayNameResponse {
1082 |   status: string;
1083 |   response: {
1084 |     type: string;
1085 |   };
1086 | }
1087 | 
1088 | export interface SpotUserResponse {
1089 |   status: string;
1090 |   response: {
1091 |     type: string;
1092 |   };
1093 | }
1094 | 
1095 | export interface CDepositResponse {
1096 |   status: string;
1097 |   response: {
1098 |     type: string;
1099 |   };
1100 | }
1101 | 
1102 | export interface CWithdrawResponse {
1103 |   status: string;
1104 |   response: {
1105 |     type: string;
1106 |   };
1107 | }
1108 | 
1109 | export interface TokenDelegateResponse {
1110 |   status: string;
1111 |   response: {
1112 |     type: string;
1113 |   };
1114 | }
1115 | 
1116 | export interface SubAccountSpotTransferResponse {
1117 |   status: string;
1118 |   response: {
1119 |     type: string;
1120 |   };
1121 | }
1122 | 
1123 | export interface SubAccountTransferResponse {
1124 |   status: string;
1125 |   response: {
1126 |     type: string;
1127 |   };
1128 | }
1129 | 
1130 | export interface ReserveRequestWeightRequest {
1131 |   weight: number;
1132 | }
1133 | 
1134 | export interface ReserveRequestWeightResponse {
1135 |   status: string;
1136 |   response: {
1137 |     type: string;
1138 |   };
1139 | }
1140 | 


--------------------------------------------------------------------------------
/src/utils/environment.ts:
--------------------------------------------------------------------------------
 1 | export const environment = {
 2 |   isBrowser: typeof window !== 'undefined' && typeof window.document !== 'undefined',
 3 |   isNode:
 4 |     typeof process !== 'undefined' && process.versions != null && process.versions.node != null,
 5 |   isWebWorker:
 6 |     typeof self === 'object' &&
 7 |     self.constructor &&
 8 |     self.constructor.name === 'DedicatedWorkerGlobalScope',
 9 |   isServiceWorker:
10 |     typeof self === 'object' &&
11 |     self.constructor &&
12 |     self.constructor.name === 'ServiceWorkerGlobalScope',
13 | 
14 |   // Helper methods
15 |   hasNativeWebSocket(): boolean {
16 |     if (this.isBrowser || this.isWebWorker) {
17 |       return 'WebSocket' in (this.isBrowser ? window : self);
18 |     }
19 | 
20 |     if (this.isNode) {
21 |       // Node.js v23+ has native WebSocket support
22 |       const nodeVersion = process.versions.node;
23 |       const major = parseInt(nodeVersion.split('.')[0], 10);
24 |       return major >= 23;
25 |     }
26 | 
27 |     return false;
28 |   },
29 | 
30 |   supportsWebSocket(): boolean {
31 |     // First check for native support
32 |     if (this.hasNativeWebSocket()) {
33 |       return true;
34 |     }
35 | 
36 |     // For Node.js without native support, try to load ws package
37 |     if (this.isNode) {
38 |       try {
39 |         // Dynamic require to avoid bundling ws package in browser builds
40 |         const WebSocket = (globalThis as any).require?.('ws');
41 |         return typeof WebSocket === 'function';
42 |       } catch {
43 |         return false;
44 |       }
45 |     }
46 | 
47 |     return false;
48 |   },
49 | 
50 |   supportsLocalStorage(): boolean {
51 |     try {
52 |       return this.isBrowser && 'localStorage' in window && window.localStorage !== null;
53 |     } catch {
54 |       return false;
55 |     }
56 |   },
57 | 
58 |   supportsCrypto(): boolean {
59 |     return (
60 |       (this.isBrowser && 'crypto' in window) ||
61 |       (this.isWebWorker && 'crypto' in self) ||
62 |       (this.isNode && 'crypto' in globalThis)
63 |     );
64 |   },
65 | 
66 |   // Helper to get the appropriate global object
67 |   getGlobalObject(): any {
68 |     if (this.isBrowser) return window;
69 |     if (this.isWebWorker || this.isServiceWorker) return self;
70 |     if (this.isNode) return global;
71 |     return globalThis;
72 |   },
73 | };
74 | 


--------------------------------------------------------------------------------
/src/utils/errors.ts:
--------------------------------------------------------------------------------
 1 | export class HyperliquidAPIError extends Error {
 2 |   constructor(
 3 |     public code: string,
 4 |     message: string
 5 |   ) {
 6 |     super(message);
 7 |     this.name = 'HyperliquidAPIError';
 8 |   }
 9 | }
10 | 
11 | export class AuthenticationError extends Error {
12 |   constructor(message: string) {
13 |     super(message);
14 |     this.name = 'AuthenticationError';
15 |   }
16 | }
17 | 
18 | export function handleApiError(error: any): never {
19 |   if (error.response) {
20 |     // The request was made and the server responded with a status code
21 |     // that falls out of the range of 2xx
22 |     const errorCode =
23 |       error.response.data && error.response.data.code
24 |         ? error.response.data.code
25 |         : error.response.status || 'UNKNOWN_ERROR';
26 | 
27 |     const errorMessage = error.response.data
28 |       ? error.response.data.message ||
29 |         (typeof error.response.data === 'string'
30 |           ? error.response.data
31 |           : 'An unknown error occurred')
32 |       : 'An unknown error occurred';
33 | 
34 |     throw new HyperliquidAPIError(errorCode, errorMessage);
35 |   } else if (error.request) {
36 |     // The request was made but no response was received
37 |     throw new HyperliquidAPIError('NETWORK_ERROR', 'No response received from the server');
38 |   } else {
39 |     // Something happened in setting up the request that triggered an Error
40 |     throw new HyperliquidAPIError('REQUEST_SETUP_ERROR', error.message || 'Unknown error occurred');
41 |   }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/utils/helpers.ts:
--------------------------------------------------------------------------------
 1 | import axios, { AxiosInstance } from 'axios';
 2 | import { handleApiError } from './errors';
 3 | import { RateLimiter } from './rateLimiter';
 4 | 
 5 | export class HttpApi {
 6 |   private client: AxiosInstance;
 7 |   private endpoint: string;
 8 |   private rateLimiter: RateLimiter;
 9 | 
10 |   constructor(baseUrl: string, endpoint: string = '/', rateLimiter: RateLimiter) {
11 |     this.endpoint = endpoint;
12 |     this.client = axios.create({
13 |       baseURL: baseUrl,
14 |       headers: {
15 |         'Content-Type': 'application/json',
16 |       },
17 |     });
18 |     this.rateLimiter = rateLimiter;
19 |   }
20 | 
21 |   async makeRequest<T>(
22 |     payload: any,
23 |     weight: number = 2,
24 |     endpoint: string = this.endpoint
25 |   ): Promise<T> {
26 |     try {
27 |       await this.rateLimiter.waitForToken(weight);
28 | 
29 |       const response = await this.client.post(endpoint, payload);
30 | 
31 |       // Check if response data is null or undefined before returning
32 |       if (response.data === null || response.data === undefined) {
33 |         throw new Error('Received null or undefined response data');
34 |       }
35 | 
36 |       return response.data;
37 |     } catch (error) {
38 |       handleApiError(error);
39 |     }
40 |   }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/utils/rateLimiter.ts:
--------------------------------------------------------------------------------
 1 | export class RateLimiter {
 2 |   private tokens: number;
 3 |   private lastRefill: number;
 4 |   private readonly capacity: number;
 5 |   private readonly refillRate: number; // tokens per second
 6 | 
 7 |   constructor() {
 8 |     this.capacity = 100; // 100 tokens maximum as per API docs
 9 |     this.refillRate = 10; // 10 tokens per second as per API docs
10 |     this.tokens = this.capacity;
11 |     this.lastRefill = Date.now();
12 |   }
13 | 
14 |   private refillTokens() {
15 |     const now = Date.now();
16 |     const elapsedSeconds = (now - this.lastRefill) / 1000; // convert to seconds
17 | 
18 |     // Calculate new tokens based on elapsed time and refill rate
19 |     const newTokens = elapsedSeconds * this.refillRate;
20 | 
21 |     if (newTokens > 0) {
22 |       this.tokens = Math.min(this.capacity, this.tokens + newTokens);
23 |       this.lastRefill = now;
24 |     }
25 |   }
26 | 
27 |   async waitForToken(weight: number = 1): Promise<void> {
28 |     this.refillTokens();
29 | 
30 |     if (this.tokens >= weight) {
31 |       this.tokens -= weight;
32 |       return;
33 |     }
34 | 
35 |     // Calculate wait time needed for enough tokens to be available
36 |     const tokensNeeded = weight - this.tokens;
37 |     const waitTimeMs = (tokensNeeded / this.refillRate) * 1000;
38 | 
39 |     return new Promise(resolve => setTimeout(resolve, waitTimeMs)).then(() => {
40 |       this.refillTokens();
41 |       return this.waitForToken(weight); // recursively check again after waiting
42 |     });
43 |   }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/utils/signing.ts:
--------------------------------------------------------------------------------
  1 | import { encode } from '@msgpack/msgpack';
  2 | import { ethers, getBytes, HDNodeWallet, keccak256, type Wallet } from 'ethers';
  3 | 
  4 | import type {
  5 |   Builder,
  6 |   Order,
  7 |   OrderRequest,
  8 |   OrderType,
  9 |   OrderWire,
 10 |   Signature,
 11 |   CancelOrderRequest,
 12 |   Grouping,
 13 |   BulkOrderRequest,
 14 | } from '../types';
 15 | 
 16 | const phantomDomain = {
 17 |   name: 'Exchange',
 18 |   version: '1',
 19 |   chainId: 1337,
 20 |   verifyingContract: '0x0000000000000000000000000000000000000000',
 21 | };
 22 | 
 23 | const agentTypes = {
 24 |   Agent: [
 25 |     { name: 'source', type: 'string' },
 26 |     { name: 'connectionId', type: 'bytes32' },
 27 |   ],
 28 | } as const;
 29 | 
 30 | export function orderTypeToWire(orderType: OrderType): OrderType {
 31 |   if (orderType.limit) {
 32 |     return { limit: orderType.limit };
 33 |   } else if (orderType.trigger) {
 34 |     return {
 35 |       trigger: {
 36 |         isMarket: orderType.trigger.isMarket,
 37 |         triggerPx: floatToWire(Number(orderType.trigger.triggerPx)),
 38 |         tpsl: orderType.trigger.tpsl,
 39 |       },
 40 |     };
 41 |   }
 42 |   throw new Error('Invalid order type');
 43 | }
 44 | 
 45 | function addressToBytes(address: string): Uint8Array {
 46 |   return getBytes(address);
 47 | }
 48 | 
 49 | function actionHash(action: unknown, vaultAddress: string | null, nonce: number): string {
 50 |   // Normalize the action to remove trailing zeros from price and size fields
 51 |   const normalizedAction = normalizeTrailingZeros(action);
 52 | 
 53 |   const msgPackBytes = encode(normalizedAction);
 54 |   const additionalBytesLength = vaultAddress === null ? 9 : 29;
 55 |   const data = new Uint8Array(msgPackBytes.length + additionalBytesLength);
 56 |   data.set(msgPackBytes);
 57 |   const view = new DataView(data.buffer);
 58 |   view.setBigUint64(msgPackBytes.length, BigInt(nonce), false);
 59 |   if (vaultAddress === null) {
 60 |     view.setUint8(msgPackBytes.length + 8, 0);
 61 |   } else {
 62 |     view.setUint8(msgPackBytes.length + 8, 1);
 63 |     data.set(addressToBytes(vaultAddress), msgPackBytes.length + 9);
 64 |   }
 65 |   return keccak256(data);
 66 | }
 67 | 
 68 | function constructPhantomAgent(hash: string, isMainnet: boolean) {
 69 |   return { source: isMainnet ? 'a' : 'b', connectionId: hash };
 70 | }
 71 | 
 72 | export async function signL1Action(
 73 |   wallet: Wallet | HDNodeWallet,
 74 |   action: unknown,
 75 |   activePool: string | null,
 76 |   nonce: number,
 77 |   isMainnet: boolean
 78 | ): Promise<Signature> {
 79 |   // actionHash already normalizes the action
 80 |   const hash = actionHash(action, activePool, nonce);
 81 |   const phantomAgent = constructPhantomAgent(hash, isMainnet);
 82 |   const data = {
 83 |     domain: phantomDomain,
 84 |     types: agentTypes,
 85 |     primaryType: 'Agent',
 86 |     message: phantomAgent,
 87 |   };
 88 |   return signInner(wallet, data);
 89 | }
 90 | 
 91 | export async function signUserSignedAction(
 92 |   wallet: Wallet,
 93 |   action: any,
 94 |   payloadTypes: Array<{ name: string; type: string }>,
 95 |   primaryType: string,
 96 |   isMainnet: boolean
 97 | ): Promise<Signature> {
 98 |   const data = {
 99 |     domain: {
100 |       name: 'HyperliquidSignTransaction',
101 |       version: '1',
102 |       chainId: isMainnet ? 42161 : 421614,
103 |       verifyingContract: '0x0000000000000000000000000000000000000000',
104 |     },
105 |     types: {
106 |       [primaryType]: payloadTypes, // Do not add user field here
107 |     },
108 |     primaryType: primaryType,
109 |     message: action,
110 |   };
111 | 
112 |   return signInner(wallet, data);
113 | }
114 | 
115 | export async function signUsdTransferAction(
116 |   wallet: Wallet,
117 |   action: any,
118 |   isMainnet: boolean
119 | ): Promise<Signature> {
120 |   return signUserSignedAction(
121 |     wallet,
122 |     action,
123 |     [
124 |       { name: 'hyperliquidChain', type: 'string' },
125 |       { name: 'destination', type: 'string' },
126 |       { name: 'amount', type: 'string' },
127 |       { name: 'time', type: 'uint64' },
128 |     ],
129 |     'HyperliquidTransaction:UsdSend',
130 |     isMainnet
131 |   );
132 | }
133 | 
134 | export async function signWithdrawFromBridgeAction(
135 |   wallet: Wallet,
136 |   action: any,
137 |   isMainnet: boolean
138 | ): Promise<Signature> {
139 |   return signUserSignedAction(
140 |     wallet,
141 |     action,
142 |     [
143 |       { name: 'hyperliquidChain', type: 'string' },
144 |       { name: 'destination', type: 'string' },
145 |       { name: 'amount', type: 'string' },
146 |       { name: 'time', type: 'uint64' },
147 |     ],
148 |     'HyperliquidTransaction:Withdraw',
149 |     isMainnet
150 |   );
151 | }
152 | 
153 | export async function signAgent(
154 |   wallet: Wallet,
155 |   action: any,
156 |   isMainnet: boolean
157 | ): Promise<Signature> {
158 |   return signUserSignedAction(
159 |     wallet,
160 |     action,
161 |     [
162 |       { name: 'hyperliquidChain', type: 'string' },
163 |       { name: 'agentAddress', type: 'address' },
164 |       { name: 'agentName', type: 'string' },
165 |       { name: 'nonce', type: 'uint64' },
166 |     ],
167 |     'HyperliquidTransaction:ApproveAgent',
168 |     isMainnet
169 |   );
170 | }
171 | 
172 | async function signInner(wallet: Wallet | HDNodeWallet, data: any): Promise<Signature> {
173 |   const signature = await wallet.signTypedData(data.domain, data.types, data.message);
174 |   return splitSig(signature);
175 | }
176 | 
177 | function splitSig(sig: string): Signature {
178 |   const { r, s, v } = ethers.Signature.from(sig);
179 |   return { r, s, v };
180 | }
181 | 
182 | export function floatToWire(x: number): string {
183 |   const rounded = x.toFixed(8);
184 |   if (Math.abs(parseFloat(rounded) - x) >= 1e-12) {
185 |     throw new Error(`floatToWire causes rounding: ${x}`);
186 |   }
187 |   let normalized = rounded.replace(/\.?0+$/, '');
188 |   if (normalized === '-0') normalized = '0';
189 |   return normalized;
190 | }
191 | 
192 | /**
193 |  * Removes trailing zeros from a string representation of a number.
194 |  * This is useful when working with price and size fields directly.
195 |  *
196 |  * Hyperliquid API requires that price ('p') and size ('s') fields do not contain trailing zeros.
197 |  * For example, "12345.0" should be "12345" and "0.123450" should be "0.12345".
198 |  * This function ensures that all numeric string values are properly formatted.
199 |  *
200 |  * @param value - The string value to normalize
201 |  * @returns The normalized string without trailing zeros
202 |  */
203 | export function removeTrailingZeros(value: string): string {
204 |   if (!value.includes('.')) return value;
205 | 
206 |   const normalized = value.replace(/\.?0+$/, '');
207 |   if (normalized === '-0') return '0';
208 |   return normalized;
209 | }
210 | 
211 | export function floatToIntForHashing(x: number): number {
212 |   return floatToInt(x, 8);
213 | }
214 | 
215 | export function floatToUsdInt(x: number): number {
216 |   return floatToInt(x, 6);
217 | }
218 | 
219 | function floatToInt(x: number, power: number): number {
220 |   const withDecimals = x * Math.pow(10, power);
221 |   if (Math.abs(Math.round(withDecimals) - withDecimals) >= 1e-3) {
222 |     throw new Error(`floatToInt causes rounding: ${x}`);
223 |   }
224 |   return Math.round(withDecimals);
225 | }
226 | 
227 | export function getTimestampMs(): number {
228 |   return Date.now();
229 | }
230 | 
231 | export function orderToWire(order: Order | OrderRequest, asset: number): OrderWire {
232 |   const orderWire: OrderWire = {
233 |     a: asset,
234 |     b: order.is_buy,
235 |     p:
236 |       typeof order.limit_px === 'string'
237 |         ? removeTrailingZeros(order.limit_px)
238 |         : floatToWire(order.limit_px),
239 |     s: typeof order.sz === 'string' ? removeTrailingZeros(order.sz) : floatToWire(order.sz),
240 |     r: order.reduce_only,
241 |     t: orderTypeToWire(order.order_type),
242 |   };
243 |   if (order.cloid !== undefined) {
244 |     orderWire.c = order.cloid;
245 |   }
246 |   return orderWire;
247 | }
248 | 
249 | export function orderWireToAction(
250 |   orders: OrderWire[],
251 |   grouping: Grouping = 'na',
252 |   builder?: Builder
253 | ): any {
254 |   return {
255 |     type: 'order',
256 |     orders: orders,
257 |     grouping: grouping,
258 |     ...(builder !== undefined
259 |       ? {
260 |           builder: {
261 |             b: builder.address.toLowerCase(),
262 |             f: builder.fee,
263 |           },
264 |         }
265 |       : {}),
266 |   };
267 | }
268 | 
269 | /**
270 |  * Normalizes an object by removing trailing zeros from price ('p') and size ('s') fields.
271 |  * This is useful when working with actions that contain these fields.
272 |  *
273 |  * Hyperliquid API requires that price ('p') and size ('s') fields do not contain trailing zeros.
274 |  * This function recursively processes an object and its nested properties to ensure all
275 |  * price and size fields are properly formatted according to API requirements.
276 |  *
277 |  * This helps prevent the "L1 error: User or API Wallet 0x... does not exist" error
278 |  * that can occur when trailing zeros are present in these fields.
279 |  *
280 |  * @param obj - The object to normalize
281 |  * @returns A new object with normalized price and size fields
282 |  */
283 | export function normalizeTrailingZeros<T>(obj: T): T {
284 |   if (!obj || typeof obj !== 'object') return obj;
285 | 
286 |   // Handle arrays
287 |   if (Array.isArray(obj)) {
288 |     return obj.map(item => normalizeTrailingZeros(item)) as unknown as T;
289 |   }
290 | 
291 |   // Process object properties
292 |   const result = { ...obj };
293 | 
294 |   for (const key in result) {
295 |     if (Object.prototype.hasOwnProperty.call(result, key)) {
296 |       const value = result[key];
297 | 
298 |       // Recursively process nested objects
299 |       if (value && typeof value === 'object') {
300 |         result[key] = normalizeTrailingZeros(value);
301 |       }
302 |       // Handle price and size fields
303 |       else if ((key === 'p' || key === 's') && typeof value === 'string') {
304 |         result[key] = removeTrailingZeros(value) as any;
305 |       }
306 |     }
307 |   }
308 | 
309 |   return result;
310 | }
311 | 
312 | export interface CancelOrderResponse {
313 |   status: string;
314 |   response: {
315 |     type: string;
316 |     data: {
317 |       statuses: string[];
318 |     };
319 |   };
320 | }
321 | 
322 | export function cancelOrderToAction(cancelRequest: CancelOrderRequest): any {
323 |   return {
324 |     type: 'cancel',
325 |     cancels: [cancelRequest],
326 |   };
327 | }
328 | 


--------------------------------------------------------------------------------
/src/utils/symbolConversion.ts:
--------------------------------------------------------------------------------
  1 | import { HttpApi } from './helpers';
  2 | import * as CONSTANTS from '../types/constants';
  3 | import { MetaAndAssetCtxs, SpotMetaAndAssetCtxs } from '../types';
  4 | 
  5 | export class SymbolConversion {
  6 |   private assetToIndexMap: Map<string, number> = new Map();
  7 |   private exchangeToInternalNameMap: Map<string, string> = new Map();
  8 |   private httpApi: HttpApi;
  9 |   private refreshIntervalMs: number = 60000;
 10 |   private refreshInterval: any = null;
 11 |   private initialized: boolean = false;
 12 |   private consecutiveFailures: number = 0;
 13 |   private maxConsecutiveFailures: number = 5;
 14 |   private baseRetryDelayMs: number = 1000;
 15 | 
 16 |   constructor(baseURL: string, rateLimiter: any) {
 17 |     this.httpApi = new HttpApi(baseURL, CONSTANTS.ENDPOINTS.INFO, rateLimiter);
 18 |   }
 19 | 
 20 |   async initialize(): Promise<void> {
 21 |     if (this.initialized) return;
 22 | 
 23 |     try {
 24 |       await this.refreshAssetMaps();
 25 |       this.startPeriodicRefresh();
 26 |       this.initialized = true;
 27 |     } catch (error) {
 28 |       console.error('Failed to initialize SymbolConversion:', error);
 29 |       throw error;
 30 |     }
 31 |   }
 32 | 
 33 |   private ensureInitialized(): void {
 34 |     if (!this.initialized) {
 35 |       throw new Error('SymbolConversion must be initialized before use. Call initialize() first.');
 36 |     }
 37 |   }
 38 | 
 39 |   async getInternalName(exchangeName: string): Promise<string | undefined> {
 40 |     this.ensureInitialized();
 41 |     return this.exchangeToInternalNameMap.get(exchangeName);
 42 |   }
 43 | 
 44 |   private startPeriodicRefresh(): void {
 45 |     if (this.refreshInterval !== null) {
 46 |       clearInterval(this.refreshInterval);
 47 |     }
 48 | 
 49 |     // Use standard setInterval that works in both Node.js and browser
 50 |     this.refreshInterval = setInterval(() => {
 51 |       this.refreshAssetMaps().catch(error => {
 52 |         console.error('Failed to refresh asset maps:', error);
 53 |         // Increment consecutive failures counter
 54 |         this.consecutiveFailures++;
 55 | 
 56 |         // If we've reached the maximum number of consecutive failures, stop refreshing
 57 |         if (this.consecutiveFailures >= this.maxConsecutiveFailures) {
 58 |           console.warn(
 59 |             `Maximum consecutive failures (${this.maxConsecutiveFailures}) reached. Stopping automatic refresh.`
 60 |           );
 61 |           this.stopPeriodicRefresh();
 62 |         }
 63 |       });
 64 |     }, this.refreshIntervalMs);
 65 |   }
 66 | 
 67 |   // Check if max failures has been reached and stop refresh if needed
 68 |   private checkMaxFailures(): void {
 69 |     if (this.consecutiveFailures >= this.maxConsecutiveFailures) {
 70 |       console.warn(
 71 |         `Maximum consecutive failures (${this.maxConsecutiveFailures}) reached. Stopping automatic refresh.`
 72 |       );
 73 |       this.stopPeriodicRefresh();
 74 |     }
 75 |   }
 76 | 
 77 |   public stopPeriodicRefresh(): void {
 78 |     if (this.refreshInterval !== null) {
 79 |       clearInterval(this.refreshInterval);
 80 |       this.refreshInterval = null;
 81 |     }
 82 |   }
 83 | 
 84 |   private async refreshAssetMaps(): Promise<void> {
 85 |     try {
 86 |       const [perpMeta, spotMeta] = await Promise.all([
 87 |         this.httpApi.makeRequest<MetaAndAssetCtxs>({
 88 |           type: CONSTANTS.InfoType.PERPS_META_AND_ASSET_CTXS,
 89 |         }),
 90 |         this.httpApi.makeRequest<SpotMetaAndAssetCtxs>({
 91 |           type: CONSTANTS.InfoType.SPOT_META_AND_ASSET_CTXS,
 92 |         }),
 93 |       ]);
 94 | 
 95 |       // Verify responses are valid before proceeding
 96 |       if (
 97 |         !perpMeta ||
 98 |         !perpMeta[0] ||
 99 |         !perpMeta[0].universe ||
100 |         !Array.isArray(perpMeta[0].universe)
101 |       ) {
102 |         throw new Error('Invalid perpetual metadata response');
103 |       }
104 | 
105 |       if (
106 |         !spotMeta ||
107 |         !spotMeta[0] ||
108 |         !spotMeta[0].tokens ||
109 |         !Array.isArray(spotMeta[0].tokens) ||
110 |         !spotMeta[0].universe ||
111 |         !Array.isArray(spotMeta[0].universe)
112 |       ) {
113 |         throw new Error('Invalid spot metadata response');
114 |       }
115 | 
116 |       this.assetToIndexMap.clear();
117 |       this.exchangeToInternalNameMap.clear();
118 | 
119 |       // Handle perpetual assets
120 |       perpMeta[0].universe.forEach((asset: { name: string }, index: number) => {
121 |         const internalName = `${asset.name}-PERP`;
122 |         this.assetToIndexMap.set(internalName, index);
123 |         this.exchangeToInternalNameMap.set(asset.name, internalName);
124 |       });
125 | 
126 |       // Handle spot assets
127 |       spotMeta[0].tokens.forEach((token: any) => {
128 |         const universeItem = spotMeta[0].universe.find(
129 |           (item: any) => item.tokens[0] === token.index
130 |         );
131 |         if (universeItem) {
132 |           const internalName = `${token.name}-SPOT`;
133 |           const exchangeName = universeItem.name;
134 |           const index = universeItem.index;
135 |           this.assetToIndexMap.set(internalName, 10000 + index);
136 |           this.exchangeToInternalNameMap.set(exchangeName, internalName);
137 |         }
138 |       });
139 | 
140 |       // Reset consecutive failures counter on success
141 |       this.consecutiveFailures = 0;
142 |     } catch (error) {
143 |       // Increment consecutive failures counter
144 |       this.consecutiveFailures++;
145 | 
146 |       // Check if we've reached the maximum number of consecutive failures
147 |       this.checkMaxFailures();
148 | 
149 |       // Propagate the error to be handled by the caller
150 |       throw error;
151 |     }
152 |   }
153 | 
154 |   public async getExchangeName(internalName: string): Promise<string | undefined> {
155 |     await this.ensureInitialized();
156 |     for (const [exchangeName, name] of this.exchangeToInternalNameMap.entries()) {
157 |       if (name === internalName) {
158 |         return exchangeName;
159 |       }
160 |     }
161 |     return undefined;
162 |   }
163 | 
164 |   public async getAssetIndex(assetSymbol: string): Promise<number | undefined> {
165 |     await this.ensureInitialized();
166 |     return this.assetToIndexMap.get(assetSymbol);
167 |   }
168 | 
169 |   public async getAllAssets(): Promise<{ perp: string[]; spot: string[] }> {
170 |     await this.ensureInitialized();
171 |     const perp: string[] = [];
172 |     const spot: string[] = [];
173 | 
174 |     for (const [asset, index] of this.assetToIndexMap.entries()) {
175 |       if (asset.endsWith('-PERP')) {
176 |         perp.push(asset);
177 |       } else if (asset.endsWith('-SPOT')) {
178 |         spot.push(asset);
179 |       }
180 |     }
181 | 
182 |     return { perp, spot };
183 |   }
184 | 
185 |   async convertSymbol(symbol: string, mode: string = '', symbolMode: string = ''): Promise<string> {
186 |     await this.ensureInitialized();
187 |     let rSymbol: string;
188 |     if (mode === 'reverse') {
189 |       for (const [key, value] of this.exchangeToInternalNameMap.entries()) {
190 |         if (value === symbol) {
191 |           return key;
192 |         }
193 |       }
194 |       rSymbol = symbol;
195 |     } else {
196 |       rSymbol = this.exchangeToInternalNameMap.get(symbol) || symbol;
197 |     }
198 | 
199 |     if (symbolMode === 'SPOT') {
200 |       if (!rSymbol.endsWith('-SPOT')) {
201 |         rSymbol = symbol + '-SPOT';
202 |       }
203 |     } else if (symbolMode === 'PERP') {
204 |       if (!rSymbol.endsWith('-PERP')) {
205 |         rSymbol = symbol + '-PERP';
206 |       }
207 |     }
208 | 
209 |     return rSymbol;
210 |   }
211 | 
212 |   async convertSymbolsInObject(
213 |     obj: any,
214 |     symbolsFields: Array<string> = ['coin', 'symbol'],
215 |     symbolMode: string = ''
216 |   ): Promise<any> {
217 |     await this.ensureInitialized();
218 |     if (typeof obj !== 'object' || obj === null) {
219 |       return this.convertToNumber(obj);
220 |     }
221 | 
222 |     if (Array.isArray(obj)) {
223 |       return Promise.all(
224 |         obj.map(item => this.convertSymbolsInObject(item, symbolsFields, symbolMode))
225 |       );
226 |     }
227 | 
228 |     const convertedObj: any = {};
229 |     for (const [key, value] of Object.entries(obj)) {
230 |       if (symbolsFields.includes(key)) {
231 |         convertedObj[key] = await this.convertSymbol(value as string, '', symbolMode);
232 |       } else if (key === 'side') {
233 |         convertedObj[key] = value === 'A' ? 'sell' : value === 'B' ? 'buy' : value;
234 |       } else {
235 |         convertedObj[key] = await this.convertSymbolsInObject(value, symbolsFields, symbolMode);
236 |       }
237 |     }
238 |     return convertedObj;
239 |   }
240 | 
241 |   convertToNumber(value: any): any {
242 |     if (typeof value === 'string') {
243 |       if (/^-?\d+$/.test(value)) {
244 |         return parseInt(value, 10);
245 |       } else if (/^-?\d*\.\d+$/.test(value)) {
246 |         return parseFloat(value);
247 |       }
248 |     }
249 |     return value;
250 |   }
251 | 
252 |   async convertResponse(
253 |     response: any,
254 |     symbolsFields: string[] = ['coin', 'symbol'],
255 |     symbolMode: string = ''
256 |   ): Promise<any> {
257 |     return this.convertSymbolsInObject(response, symbolsFields, symbolMode);
258 |   }
259 | }
260 | 


--------------------------------------------------------------------------------
/src/websocket/connection.ts:
--------------------------------------------------------------------------------
  1 | import * as CONSTANTS from '../types/constants';
  2 | import { environment } from '../utils/environment';
  3 | 
  4 | export class WebSocketClient {
  5 |   private ws: WebSocket | any = null; // 'any' to support both native WebSocket and ws package
  6 |   private url: string;
  7 |   private pingInterval: number | null = null;
  8 |   private reconnectAttempts: number = 0;
  9 |   private maxReconnectAttempts: number = 5;
 10 |   private reconnectDelay: number = 5000;
 11 |   private initialReconnectDelay: number = 1000;
 12 |   private maxReconnectDelay: number = 30000;
 13 |   private eventHandlers: Map<string, Set<Function>> = new Map();
 14 |   private WebSocketImpl: typeof WebSocket | null = null;
 15 |   private connected: boolean = false;
 16 |   private connecting: boolean = false;
 17 |   private connectionPromise: Promise<void> | null = null;
 18 |   private subscriptionCount: number = 0;
 19 |   private lastPongReceived: number = 0;
 20 |   private manualDisconnect: boolean = false; // Flag to track if disconnect was manually initiated
 21 |   private readonly MAX_SUBSCRIPTIONS: number = 1000; // Maximum subscriptions per IP as per API docs
 22 | 
 23 |   constructor(testnet: boolean = false, maxReconnectAttempts: number = 5) {
 24 |     this.maxReconnectAttempts = maxReconnectAttempts;
 25 |     this.url = testnet ? CONSTANTS.WSS_URLS.TESTNET : CONSTANTS.WSS_URLS.PRODUCTION;
 26 | 
 27 |     // Determine which WebSocket implementation to use
 28 |     if (environment.hasNativeWebSocket()) {
 29 |       this.WebSocketImpl = WebSocket;
 30 |     } else if (environment.isNode) {
 31 |       try {
 32 |         // Try to load ws package
 33 |         this.WebSocketImpl = (globalThis as any).require('ws');
 34 |       } catch (error) {
 35 |         this.WebSocketImpl = null;
 36 |       }
 37 |     }
 38 |   }
 39 | 
 40 |   isConnected(): boolean {
 41 |     return this.connected && this.ws?.readyState === (this.WebSocketImpl?.OPEN ?? WebSocket.OPEN);
 42 |   }
 43 | 
 44 |   connect(): Promise<void> {
 45 |     // Reset the manualDisconnect flag when connecting
 46 |     this.manualDisconnect = false;
 47 | 
 48 |     // If already connected, return immediately
 49 |     if (this.isConnected()) {
 50 |       return Promise.resolve();
 51 |     }
 52 | 
 53 |     // If connection is in progress, return existing promise
 54 |     if (this.connecting && this.connectionPromise) {
 55 |       return this.connectionPromise;
 56 |     }
 57 | 
 58 |     this.connecting = true;
 59 |     this.connectionPromise = new Promise((resolve, reject) => {
 60 |       try {
 61 |         if (!this.WebSocketImpl) {
 62 |           if (environment.isNode) {
 63 |             throw new Error(
 64 |               'This SDK requires Node.js version 22 or higher as earlier versions do not have support for the NodeJS native websockets.'
 65 |             );
 66 |           } else {
 67 |             throw new Error('WebSocket support is not available in this environment.');
 68 |           }
 69 |         }
 70 | 
 71 |         this.ws = new this.WebSocketImpl(this.url);
 72 | 
 73 |         this.ws.onopen = () => {
 74 |           console.log('WebSocket connected');
 75 |           this.connected = true;
 76 |           this.connecting = false;
 77 |           this.reconnectAttempts = 0;
 78 |           this.lastPongReceived = Date.now();
 79 |           this.startPingInterval();
 80 |           this.emit('open');
 81 |           resolve();
 82 |         };
 83 | 
 84 |         this.ws.onmessage = (event: MessageEvent) => {
 85 |           try {
 86 |             const message = JSON.parse(event.data);
 87 | 
 88 |             // Debug log for post responses
 89 |             if (message.channel === 'post') {
 90 |               console.log('Received WebSocket post response:', JSON.stringify(message));
 91 |             }
 92 | 
 93 |             // Handle pong responses
 94 |             if (message.channel === 'pong') {
 95 |               this.lastPongReceived = Date.now();
 96 |             }
 97 | 
 98 |             this.emit('message', message);
 99 |           } catch (error) {
100 |             console.error('Error processing WebSocket message:', error);
101 |             console.error('Raw message data:', event.data);
102 |           }
103 |         };
104 | 
105 |         this.ws.onerror = (event: Event) => {
106 |           console.error('WebSocket error:', event);
107 |           this.emit('error', event);
108 |           if (!this.connected) {
109 |             this.connecting = false;
110 |             reject(event);
111 |           }
112 |         };
113 | 
114 |         this.ws.onclose = () => {
115 |           console.log('WebSocket disconnected');
116 |           this.connected = false;
117 |           this.connecting = false;
118 |           this.stopPingInterval();
119 |           this.emit('close');
120 | 
121 |           // Only attempt to reconnect if not manually disconnected
122 |           if (!this.manualDisconnect) {
123 |             this.reconnect();
124 |           } else {
125 |             console.log('Manual disconnect detected, not attempting to reconnect');
126 |             this.emit('manualDisconnect');
127 |           }
128 |         };
129 |       } catch (error) {
130 |         this.connecting = false;
131 |         reject(error);
132 |       }
133 |     });
134 | 
135 |     return this.connectionPromise;
136 |   }
137 | 
138 |   private reconnect(): void {
139 |     if (this.reconnectAttempts < this.maxReconnectAttempts) {
140 |       this.reconnectAttempts++;
141 |       const delay = Math.min(
142 |         this.initialReconnectDelay * Math.pow(2, this.reconnectAttempts - 1),
143 |         this.maxReconnectDelay
144 |       );
145 |       console.log(
146 |         `Attempting to reconnect (${this.reconnectAttempts}/${this.maxReconnectAttempts}) in ${delay}ms...`
147 |       );
148 |       const timer = setTimeout(() => {
149 |         this.connect()
150 |           .then(() => {
151 |             this.emit('reconnect', true);
152 |           })
153 |           .catch(err => {
154 |             console.error('Reconnection failed:', err);
155 |             this.emit('error', err);
156 |             this.reconnect();
157 |           });
158 |       }, delay);
159 |       // Only call unref if available (Node.js environment)
160 |       if (typeof timer.unref === 'function') {
161 |         timer.unref();
162 |       }
163 |     } else {
164 |       console.error('Max reconnection attempts reached. Please reconnect manually.');
165 |       this.emit('maxReconnectAttemptsReached');
166 |     }
167 |   }
168 | 
169 |   private startPingInterval(): void {
170 |     this.pingInterval = setInterval(() => {
171 |       if (this.isConnected()) {
172 |         // Send ping message
173 |         this.sendMessage({ method: 'ping' });
174 | 
175 |         // Check if we've received a pong recently (within 30 seconds)
176 |         const now = Date.now();
177 |         if (now - this.lastPongReceived > 30000) {
178 |           console.warn('No pong received in the last 30 seconds, reconnecting...');
179 |           this.close();
180 |           // Only attempt to reconnect if not manually disconnected
181 |           if (!this.manualDisconnect) {
182 |             this.connect().catch(err => {
183 |               console.error('Failed to reconnect after ping timeout:', err);
184 |             });
185 |           }
186 |         }
187 |       }
188 |     }, 15000) as unknown as number;
189 |   }
190 | 
191 |   private stopPingInterval(): void {
192 |     if (this.pingInterval !== null) {
193 |       clearInterval(this.pingInterval);
194 |       this.pingInterval = null;
195 |     }
196 |   }
197 | 
198 |   sendMessage(message: any): void {
199 |     if (!this.isConnected()) {
200 |       throw new Error('WebSocket is not connected');
201 |     }
202 |     this.ws.send(JSON.stringify(message));
203 |   }
204 | 
205 |   close(manualDisconnect: boolean = false): void {
206 |     this.manualDisconnect = manualDisconnect;
207 |     if (this.ws) {
208 |       this.connected = false;
209 |       this.connecting = false;
210 |       this.ws.close();
211 |     }
212 |     this.stopPingInterval();
213 |   }
214 | 
215 |   on(event: string, handler: Function): void {
216 |     if (!this.eventHandlers.has(event)) {
217 |       this.eventHandlers.set(event, new Set());
218 |     }
219 |     this.eventHandlers.get(event)?.add(handler);
220 |   }
221 | 
222 |   removeListener(event: string, handler: Function): void {
223 |     const handlers = this.eventHandlers.get(event);
224 |     if (handlers) {
225 |       handlers.delete(handler);
226 |     }
227 |   }
228 | 
229 |   removeAllListeners(event?: string): void {
230 |     if (event) {
231 |       this.eventHandlers.delete(event);
232 |     } else {
233 |       this.eventHandlers.clear();
234 |     }
235 |   }
236 | 
237 |   private emit(event: string, ...args: any[]): void {
238 |     const handlers = this.eventHandlers.get(event);
239 |     if (handlers) {
240 |       handlers.forEach(handler => handler(...args));
241 |     }
242 |   }
243 | 
244 |   // Track subscription count
245 |   incrementSubscriptionCount(): boolean {
246 |     if (this.subscriptionCount >= this.MAX_SUBSCRIPTIONS) {
247 |       console.error(`Maximum subscription limit (${this.MAX_SUBSCRIPTIONS}) reached`);
248 |       return false;
249 |     }
250 |     this.subscriptionCount++;
251 |     return true;
252 |   }
253 | 
254 |   decrementSubscriptionCount(): void {
255 |     if (this.subscriptionCount > 0) {
256 |       this.subscriptionCount--;
257 |     }
258 |   }
259 | 
260 |   getSubscriptionCount(): number {
261 |     return this.subscriptionCount;
262 |   }
263 | }
264 | 


--------------------------------------------------------------------------------
/tests/test1.js:
--------------------------------------------------------------------------------
1 | console.log("need to add some tests")


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "target": "ES2022",
 4 |     "module": "ES2022",
 5 |     "moduleResolution": "bundler",
 6 |     "lib": ["ES2022", "DOM"],
 7 |     "outDir": "./dist",
 8 |     "rootDir": "./src",
 9 |     "strict": true,
10 |     "esModuleInterop": true,
11 |     "skipLibCheck": true,
12 |     "forceConsistentCasingInFileNames": true,
13 |     "useDefineForClassFields": true,
14 |     "declaration": true
15 |   },
16 |   "include": ["src/**/*"],
17 |   "exclude": ["node_modules", "dist"]
18 | }
19 | 


--------------------------------------------------------------------------------
/tsup.config.ts:
--------------------------------------------------------------------------------
 1 | import { defineConfig } from 'tsup';
 2 | 
 3 | export default defineConfig([
 4 |     // Main build
 5 |     {
 6 |         entry: ['src/index.ts'],
 7 |         format: ['cjs', 'esm'],
 8 |         dts: true,
 9 |         clean: true,
10 |         sourcemap: true,
11 |         minify: true,
12 |         target: 'node16',
13 |     },
14 |     // Browser build
15 |     {
16 |         entry: ['src/browser.ts'],
17 |         format: ['iife'],
18 |         globalName: 'HyperliquidSDK',
19 |         platform: 'browser',
20 |         target: 'es2020',
21 |         minify: true,
22 |         sourcemap: true,
23 |         clean: false,
24 |         outDir: 'dist',
25 |         name: 'browser',
26 |     }
27 | ]); 


--------------------------------------------------------------------------------
/update_instructions.txt:
--------------------------------------------------------------------------------
 1 | 1. Update version in package.json
 2 | 2. Commit the files you want to push to npm package (DO NOT COMMIT PACKAGE.JSON)
 3 | 3. git push
 4 | 4. commit your package.json file and write commit message "bump"
 5 | 5. git push
 6 | 6. git tag v1.4.0 #replace with ur actual version
 7 | 7. git push origin v1.4.0 #replae with actual version 
 8 | 
 9 | 
10 | Need to do it this way and commit package.json after, bc for some reason github actions runs npm publish
11 | on the second most recent commit, not the most recent one idk why


--------------------------------------------------------------------------------