@rabby-wallet/hyperliquid-sdk 1.0.1 → 1.0.2

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

@@ -18,8 +18,10 @@ export declare class WebSocketClient {
     private readonly url;
     private readonly config;
     private subscriptions;
+    private activeSubscriptions;
     private reconnectAttempts;
     private isConnecting;
+    private isManualDisconnect;
     private pendingSubscriptions;
     private heartbeatInterval;
     private readonly HEARTBEAT_INTERVAL;
@@ -90,4 +92,12 @@ export declare class WebSocketClient {
      * Get current connection state
      */
     get readyState(): number;
+    /**
+     * Get list of active subscription types
+     */
+    getActiveSubscriptions(): string[];
+    /**
+     * Reset reconnection attempts and enable auto-reconnect
+     */
+    resetReconnectState(): void;
 }

package/dist/client/websocket-client.js

@@ -18,8 +18,10 @@ class WebSocketClient {
     constructor(config) {
         this.ws = null;
         this.subscriptions = new Map();
+        this.activeSubscriptions = new Map();
         this.reconnectAttempts = 0;
         this.isConnecting = false;
+        this.isManualDisconnect = false; // 标记是否为主动断开连接
         this.pendingSubscriptions = [];
         this.heartbeatInterval = null;
         this.HEARTBEAT_INTERVAL = 50000; // 50秒发送一次心跳，小于60秒超时
@@ -67,6 +69,7 @@ class WebSocketClient {
                 this.ws.onopen = () => {
                     this.isConnecting = false;
                     this.reconnectAttempts = 0;
+                    this.isManualDisconnect = false; // 重置手动断开标志
                     console.log('hyperliquid sdk WebSocket connected');
                     // Start heartbeat
                     this.startHeartbeat();
@@ -75,10 +78,12 @@ class WebSocketClient {
                         var _a;
                         if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN) {
                             this.subscriptions.set(message.subscription.type, callback);
+                            this.activeSubscriptions.set(message.subscription.type, { message, callback });
                             this.ws.send(JSON.stringify(Object.assign(Object.assign({}, message), { method: 'subscribe' })));
                         }
                     });
                     this.pendingSubscriptions = [];
+                    console.log(`Resubscribed to ${this.activeSubscriptions.size} channels after reconnection`);
                     resolve();
                 };
                 this.ws.onmessage = (event) => {
@@ -104,10 +109,28 @@ class WebSocketClient {
                     console.log('WebSocket disconnected');
                     // Stop heartbeat
                     this.stopHeartbeat();
-                    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);
+                    // Only attempt reconnection if it's not a manual disconnect
+                    if (!this.isManualDisconnect && this.config.autoReconnect) {
+                        // Save current active subscriptions to pending for reconnection
+                        if (this.activeSubscriptions.size > 0) {
+                            this.activeSubscriptions.forEach((subscription, type) => {
+                                const existingPending = this.pendingSubscriptions.find(sub => sub.message.subscription.type === type);
+                                if (!existingPending) {
+                                    this.pendingSubscriptions.push(subscription);
+                                }
+                            });
+                        }
+                        if (this.reconnectAttempts < this.config.maxReconnectAttempts) {
+                            this.reconnectAttempts++;
+                            console.log(`Reconnecting... (${this.reconnectAttempts}/${this.config.maxReconnectAttempts})`);
+                            setTimeout(() => this.connect(), this.config.reconnectDelay);
+                        }
+                        else {
+                            console.error('Max reconnection attempts reached. Connection failed.');
+                        }
+                    }
+                    else if (this.isManualDisconnect) {
+                        this.isManualDisconnect = false; // Reset flag
                     }
                 };
                 this.ws.onerror = (error) => {
@@ -144,26 +167,31 @@ class WebSocketClient {
      * Disconnect from the WebSocket
      */
     disconnect() {
+        this.isManualDisconnect = true; // 标记为主动断开
         this.stopHeartbeat();
         if (this.ws) {
             this.ws.close();
             this.ws = null;
         }
         this.subscriptions.clear();
+        this.activeSubscriptions.clear();
         this.pendingSubscriptions = [];
+        this.reconnectAttempts = 0; // 重置重连计数
     }
     /**
      * Subscribe to a channel
      */
     subscribe(message, callback) {
         var _a;
+        const subscriptionData = { message, callback };
         if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN) {
             this.subscriptions.set(message.subscription.type, callback);
+            this.activeSubscriptions.set(message.subscription.type, subscriptionData);
             this.ws.send(JSON.stringify(Object.assign(Object.assign({}, message), { method: 'subscribe' })));
         }
         else {
             // Store pending subscription for when connection is established
-            this.pendingSubscriptions.push({ message, callback });
+            this.pendingSubscriptions.push(subscriptionData);
             // Auto-connect if not connected
             if (!this.isConnecting && (!this.ws || this.ws.readyState === WebSocket.CLOSED)) {
                 this.connect().catch(console.error);
@@ -172,12 +200,14 @@ class WebSocketClient {
         return {
             unsubscribe: () => {
                 var _a;
-                this.subscriptions.delete(message.subscription.type);
+                const type = message.subscription.type;
+                this.subscriptions.delete(type);
+                this.activeSubscriptions.delete(type);
                 if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN) {
                     this.ws.send(JSON.stringify(Object.assign(Object.assign({}, message), { method: 'unsubscribe' })));
                 }
                 // Remove from pending subscriptions
-                this.pendingSubscriptions = this.pendingSubscriptions.filter(sub => sub.message.subscription.type !== message.subscription.type);
+                this.pendingSubscriptions = this.pendingSubscriptions.filter(sub => sub.message.subscription.type !== type);
             },
         };
     }
@@ -280,5 +310,18 @@ class WebSocketClient {
         var _a, _b;
         return (_b = (_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) !== null && _b !== void 0 ? _b : WebSocket.CLOSED;
     }
+    /**
+     * Get list of active subscription types
+     */
+    getActiveSubscriptions() {
+        return Array.from(this.activeSubscriptions.keys());
+    }
+    /**
+     * Reset reconnection attempts and enable auto-reconnect
+     */
+    resetReconnectState() {
+        this.reconnectAttempts = 0;
+        this.isManualDisconnect = false;
+    }
 }
 exports.WebSocketClient = WebSocketClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rabby-wallet/hyperliquid-sdk",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Simplified Hyperliquid Perpetuals Trading SDK for Frontend Applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",