@rabby-wallet/hyperliquid-sdk 1.0.0-beta.1

package/dist/client/info-client.js

@@ -0,0 +1,140 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InfoClient = void 0;
+const http_client_1 = require("./http-client");
+const constants_1 = require("../types/constants");
+/**
+ * Client for querying Hyperliquid info endpoints (perpetuals only)
+ * Only includes essential APIs as specified
+ */
+class InfoClient {
+    constructor(config) {
+        this.masterAddress = config.masterAddress;
+        this.httpClient = new http_client_1.HttpClient({
+            isTestnet: config.isTestnet,
+            timeout: config.timeout,
+        });
+        this.symbolConversion = config.symbolConversion;
+    }
+    /**
+     * Get all mid prices for all assets
+     */
+    getAllMids() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.info({
+                type: constants_1.InfoType.ALL_MIDS,
+            });
+        });
+    }
+    /**
+     * Get metadata and asset contexts
+     */
+    metaAndAssetCtxs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.info({
+                type: constants_1.InfoType.META_AND_ASSET_CTXS,
+            });
+        });
+    }
+    getClearingHouseState() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.info({
+                type: constants_1.InfoType.CLEARINGHOUSE_STATE,
+                user: this.masterAddress,
+            });
+        });
+    }
+    // frontendOpenOrders
+    getFrontendOpenOrders() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.info({
+                type: constants_1.InfoType.FRONTEND_OPEN_ORDERS,
+                user: this.masterAddress,
+            });
+        });
+    }
+    //  need use getFrontendOpenOrders
+    //   async getOpenOrders(): Promise<any> {
+    //     return this.httpClient.info({
+    //       type: InfoType.USER_OPEN_ORDERS,
+    //       user: this.masterAddress,
+    //     });
+    //   }
+    /**
+     * Get user's fill history
+     */
+    getUserFills() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.info({
+                type: constants_1.InfoType.USER_FILLS,
+                user: this.masterAddress,
+            });
+        });
+    }
+    /**
+     * Get candlestick data snapshot
+     * Supported intervals: "1m", "3m", "5m", "15m", "30m", "1h", "2h", "4h", "8h", "12h", "1d", "3d", "1w", "1M"
+     */
+    candleSnapshot(coin, interval, startTime, endTime) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // if no time range is specified, default to 24 hours ago 
+            const now = Date.now();
+            const defaultStartTime = now - 24 * 60 * 60 * 1000; // 24 hours ago
+            return this.httpClient.info({
+                type: constants_1.InfoType.CANDLES_SNAPSHOT,
+                req: {
+                    coin,
+                    interval,
+                    startTime: startTime || defaultStartTime,
+                    endTime: endTime || now,
+                },
+            });
+        });
+    }
+    /**
+     * Check builder fee approval status
+     */
+    checkBuilderFeeApproval(builder) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.info({
+                type: constants_1.InfoType.CHECK_BUILDER_FEE_APPROVAL,
+                user: this.masterAddress,
+                builder,
+            });
+        });
+    }
+    /**
+     * Get user fees information
+     */
+    getUsersFees() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.httpClient.info({
+                type: constants_1.InfoType.USER_FEES,
+                user: this.masterAddress,
+            });
+            // const perpFee = Number(res.userCrossRate) * (1 - Number(res.activeReferralDiscount));
+            return res;
+        });
+    }
+    /**
+     * Get user's approved persistent agents
+     */
+    extraAgents() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.info({
+                type: constants_1.InfoType.EXTRA_AGENTS,
+                user: this.masterAddress,
+            });
+        });
+    }
+}
+exports.InfoClient = InfoClient;

package/dist/client/symbolConversion.d.ts

@@ -0,0 +1,14 @@
+import { HttpClientConfig } from "./http-client";
+export declare class SymbolConversion {
+    private assetToIndexMap;
+    private httpClient;
+    private initialized;
+    constructor(config: HttpClientConfig);
+    initialize(): Promise<void>;
+    private ensureInitialized;
+    private refreshAssetMaps;
+    getAssetIndex(assetSymbol: string): Promise<number>;
+    getAllAssets(): Promise<{
+        perp: string[];
+    }>;
+}

package/dist/client/symbolConversion.js

@@ -0,0 +1,91 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymbolConversion = void 0;
+const constants_1 = require("../types/constants");
+const http_client_1 = require("./http-client");
+class SymbolConversion {
+    constructor(config) {
+        this.assetToIndexMap = new Map();
+        this.initialized = false;
+        this.httpClient = new http_client_1.HttpClient({
+            isTestnet: config.isTestnet,
+            timeout: config.timeout,
+        });
+        this.initialize();
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.initialized)
+                return;
+            try {
+                yield this.refreshAssetMaps();
+                this.initialized = true;
+            }
+            catch (error) {
+                console.error('Failed to initialize SymbolConversion:', error);
+                throw error;
+            }
+        });
+    }
+    ensureInitialized() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.initialized) {
+                yield this.initialize();
+            }
+        });
+    }
+    refreshAssetMaps() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const perpMeta = yield this.httpClient.info({
+                    type: constants_1.InfoType.META_AND_ASSET_CTXS,
+                });
+                // Verify responses are valid before proceeding
+                if (!perpMeta ||
+                    !perpMeta[0] ||
+                    !perpMeta[0].universe ||
+                    !Array.isArray(perpMeta[0].universe)) {
+                    throw new Error('Invalid perpetual metadata response');
+                }
+                this.assetToIndexMap.clear();
+                // Handle perpetual assets
+                perpMeta[0].universe.forEach((asset, index) => {
+                    this.assetToIndexMap.set(asset.name, index);
+                });
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    getAssetIndex(assetSymbol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.ensureInitialized();
+            const index = this.assetToIndexMap.get(assetSymbol);
+            if (index === undefined) {
+                throw new Error(`Unknown asset: ${assetSymbol}`);
+            }
+            return index;
+        });
+    }
+    getAllAssets() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.ensureInitialized();
+            const perp = [];
+            for (const [asset, index] of this.assetToIndexMap.entries()) {
+                perp.push(asset);
+            }
+            return { perp };
+        });
+    }
+}
+exports.SymbolConversion = SymbolConversion;

package/dist/client/websocket-client.d.ts

@@ -0,0 +1,82 @@
+import type { AllMids, L2Book, Candle, WsFill, WsOrder, WebData2 } from '../types';
+import { SymbolConversion } from './symbolConversion';
+export interface WebSocketClientConfig {
+    masterAddress: string;
+    isTestnet?: boolean;
+    autoReconnect?: boolean;
+    reconnectDelay?: number;
+    maxReconnectAttempts?: number;
+    symbolConversion: SymbolConversion;
+}
+export type SubscriptionCallback<T = any> = (data: T) => void;
+export interface Subscription {
+    unsubscribe(): void;
+}
+/**
+ * WebSocket client for real-time Hyperliquid data (perpetuals only)
+ */
+export declare class WebSocketClient {
+    private ws;
+    private readonly url;
+    private readonly config;
+    private subscriptions;
+    private subscriptionId;
+    private reconnectAttempts;
+    private isConnecting;
+    private pendingSubscriptions;
+    private symbolConversion;
+    constructor(config: WebSocketClientConfig);
+    /**
+     * Connect to the WebSocket
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the WebSocket
+     */
+    disconnect(): void;
+    /**
+     * Subscribe to a channel
+     */
+    private subscribe;
+    /**
+     * Subscribe to all mid prices
+     */
+    subscribeToAllMids(callback: SubscriptionCallback<AllMids>): Subscription;
+    /**
+     * Subscribe to L2 order book for a specific coin
+     */
+    subscribeToL2Book(coin: string, callback: SubscriptionCallback<L2Book>): Subscription;
+    /**
+     * Subscribe to trades for a specific coin
+     */
+    subscribeToTrades(coin: string, callback: SubscriptionCallback<any[]>): Subscription;
+    /**
+     * Subscribe to candlestick data
+     */
+    subscribeToCandles(coin: string, interval: string, callback: SubscriptionCallback<Candle>): Subscription;
+    /**
+     * Subscribe to user fills
+     */
+    subscribeToUserFills(callback: SubscriptionCallback<WsFill[]>): Subscription;
+    /**
+     * Subscribe to user order updates
+     */
+    subscribeToUserOrders(callback: SubscriptionCallback<WsOrder[]>): Subscription;
+    /**
+     * Subscribe to user funding updates
+     */
+    subscribeToUserFunding(callback: SubscriptionCallback<any>): Subscription;
+    /**
+     * Subscribe to webData2 - comprehensive user data updates
+     * Includes positions, margin summary, open orders, and other user data
+     */
+    subscribeToWebData2(callback: SubscriptionCallback<WebData2>): Subscription;
+    /**
+     * Check if WebSocket is connected
+     */
+    get isConnected(): boolean;
+    /**
+     * Get current connection state
+     */
+    get readyState(): number;
+}

package/dist/client/websocket-client.js

@@ -0,0 +1,227 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketClient = void 0;
+const constants_1 = require("../types/constants");
+/**
+ * WebSocket client for real-time Hyperliquid data (perpetuals only)
+ */
+class WebSocketClient {
+    constructor(config) {
+        this.ws = null;
+        this.subscriptions = new Map();
+        this.subscriptionId = 0;
+        this.reconnectAttempts = 0;
+        this.isConnecting = false;
+        this.pendingSubscriptions = [];
+        this.config = Object.assign({ isTestnet: false, autoReconnect: true, reconnectDelay: 3000, maxReconnectAttempts: 5 }, config);
+        this.url = this.config.isTestnet ? constants_1.WSS_URLS.TESTNET : constants_1.WSS_URLS.PRODUCTION;
+        this.symbolConversion = config.symbolConversion;
+    }
+    /**
+     * Connect to the WebSocket
+     */
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN) {
+                return;
+            }
+            if (this.isConnecting) {
+                return new Promise((resolve, reject) => {
+                    const checkConnection = () => {
+                        var _a;
+                        if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN) {
+                            resolve();
+                        }
+                        else if (!this.isConnecting) {
+                            reject(new Error('Failed to connect'));
+                        }
+                        else {
+                            setTimeout(checkConnection, 100);
+                        }
+                    };
+                    checkConnection();
+                });
+            }
+            return new Promise((resolve, reject) => {
+                this.isConnecting = true;
+                this.ws = new WebSocket(this.url);
+                this.ws.onopen = () => {
+                    this.isConnecting = false;
+                    this.reconnectAttempts = 0;
+                    console.log('WebSocket connected');
+                    // Resubscribe to pending subscriptions
+                    this.pendingSubscriptions.forEach(({ id, message, callback }) => {
+                        var _a;
+                        this.subscriptions.set(id, callback);
+                        if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN) {
+                            this.ws.send(JSON.stringify(message));
+                        }
+                    });
+                    this.pendingSubscriptions = [];
+                    resolve();
+                };
+                this.ws.onmessage = (event) => {
+                    try {
+                        const data = JSON.parse(event.data);
+                        if (data.method === 'subscription') {
+                            const subscriptionId = data.subscription;
+                            const callback = this.subscriptions.get(subscriptionId);
+                            if (callback) {
+                                callback(data.data);
+                            }
+                        }
+                    }
+                    catch (error) {
+                        console.error('Error parsing WebSocket message:', error);
+                    }
+                };
+                this.ws.onclose = () => {
+                    this.isConnecting = false;
+                    console.log('WebSocket disconnected');
+                    if (this.config.autoReconnect && this.reconnectAttempts < this.config.maxReconnectAttempts) {
+                        this.reconnectAttempts++;
+                        console.log(`Reconnecting... (${this.reconnectAttempts}/${this.config.maxReconnectAttempts})`);
+                        setTimeout(() => this.connect(), this.config.reconnectDelay);
+                    }
+                };
+                this.ws.onerror = (error) => {
+                    this.isConnecting = false;
+                    console.error('WebSocket error:', error);
+                    reject(error);
+                };
+            });
+        });
+    }
+    /**
+     * Disconnect from the WebSocket
+     */
+    disconnect() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.subscriptions.clear();
+        this.pendingSubscriptions = [];
+    }
+    /**
+     * Subscribe to a channel
+     */
+    subscribe(message, callback) {
+        var _a;
+        const id = ++this.subscriptionId;
+        const subscriptionMessage = Object.assign(Object.assign({}, message), { id });
+        if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN) {
+            this.subscriptions.set(id, callback);
+            this.ws.send(JSON.stringify(Object.assign(Object.assign({}, subscriptionMessage), { method: 'subscribe' })));
+        }
+        else {
+            // Store pending subscription for when connection is established
+            this.pendingSubscriptions.push({ id, message: subscriptionMessage, callback });
+            // Auto-connect if not connected
+            if (!this.isConnecting && (!this.ws || this.ws.readyState === WebSocket.CLOSED)) {
+                this.connect().catch(console.error);
+            }
+        }
+        return {
+            unsubscribe: () => {
+                var _a;
+                this.subscriptions.delete(id);
+                if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN) {
+                    this.ws.send(JSON.stringify(Object.assign(Object.assign({}, subscriptionMessage), { method: 'unsubscribe' })));
+                }
+                // Remove from pending subscriptions
+                this.pendingSubscriptions = this.pendingSubscriptions.filter(sub => sub.id !== id);
+            },
+        };
+    }
+    /**
+     * Subscribe to all mid prices
+     */
+    subscribeToAllMids(callback) {
+        return this.subscribe({
+            subscription: { type: 'allMids' },
+        }, callback);
+    }
+    /**
+     * Subscribe to L2 order book for a specific coin
+     */
+    subscribeToL2Book(coin, callback) {
+        return this.subscribe({
+            subscription: { type: 'l2Book', coin },
+        }, callback);
+    }
+    /**
+     * Subscribe to trades for a specific coin
+     */
+    subscribeToTrades(coin, callback) {
+        return this.subscribe({
+            subscription: { type: 'trades', coin },
+        }, callback);
+    }
+    /**
+     * Subscribe to candlestick data
+     */
+    subscribeToCandles(coin, interval, callback) {
+        return this.subscribe({
+            subscription: { type: 'candle', coin, interval },
+        }, callback);
+    }
+    /**
+     * Subscribe to user fills
+     */
+    subscribeToUserFills(callback) {
+        return this.subscribe({
+            subscription: { type: 'userFills', user: this.config.masterAddress },
+        }, callback);
+    }
+    /**
+     * Subscribe to user order updates
+     */
+    subscribeToUserOrders(callback) {
+        return this.subscribe({
+            subscription: { type: 'userEvents', user: this.config.masterAddress },
+        }, callback);
+    }
+    /**
+     * Subscribe to user funding updates
+     */
+    subscribeToUserFunding(callback) {
+        return this.subscribe({
+            subscription: { type: 'userFundings', user: this.config.masterAddress },
+        }, callback);
+    }
+    /**
+     * Subscribe to webData2 - comprehensive user data updates
+     * Includes positions, margin summary, open orders, and other user data
+     */
+    subscribeToWebData2(callback) {
+        return this.subscribe({
+            subscription: { type: 'webData2', user: this.config.masterAddress },
+        }, callback);
+    }
+    /**
+     * Check if WebSocket is connected
+     */
+    get isConnected() {
+        var _a;
+        return ((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN;
+    }
+    /**
+     * Get current connection state
+     */
+    get readyState() {
+        var _a, _b;
+        return (_b = (_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) !== null && _b !== void 0 ? _b : WebSocket.CLOSED;
+    }
+}
+exports.WebSocketClient = WebSocketClient;

package/dist/hyperliquid-sdk.d.ts

@@ -0,0 +1,53 @@
+import { InfoClient } from './client/info-client';
+import { ExchangeClient } from './client/exchange-client';
+import type { ClearinghouseState } from './types';
+import { WebSocketClient, WebSocketClientConfig } from './client/websocket-client';
+import { SymbolConversion } from './client/symbolConversion';
+export interface HyperliquidSDKConfig {
+    masterAddress: string;
+    agentPrivateKey?: string;
+    agentPublicKey?: string;
+    agentName?: string;
+    isTestnet?: boolean;
+    timeout?: number;
+    wsConfig?: WebSocketClientConfig;
+}
+/**
+ * Main Hyperliquid SDK class for perpetuals trading
+ * Simplified version with only essential APIs
+ * if use exchange api, must provide agentPrivateKey, agentPublicKey, agentName
+ */
+export declare class HyperliquidSDK {
+    readonly info: InfoClient;
+    exchange?: ExchangeClient;
+    symbolConversion: SymbolConversion;
+    readonly ws: WebSocketClient;
+    private readonly masterAddress;
+    private readonly configParams;
+    constructor(config: HyperliquidSDKConfig);
+    /**
+     * Get wallet address (only available if private key was provided)
+     */
+    get address(): string;
+    updateExchangeAgent(agentPrivateKey: string, agentPublicKey: string, agentName: string): void;
+    /**
+     * Connect to WebSocket for real-time data
+     */
+    connectWebSocket(): Promise<void>;
+    /**
+     * Disconnect from WebSocket
+     */
+    disconnectWebSocket(): void;
+    /**
+     * Check if WebSocket is connected
+     */
+    get isWebSocketConnected(): boolean;
+    /**
+     * Quick helper: Get account summary with essential info
+     */
+    getAccountSummary(): Promise<ClearinghouseState>;
+    /**
+     * Quick helper: Get market overview
+     */
+    getMarketOverview(): Promise<any>;
+}