@rabby-wallet/hyperliquid-sdk 1.1.0-beta.1 → 1.1.0-beta.3

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

@@ -1,4 +1,4 @@
-import type { OrderResponse, CancelResponse, ExchangeClientConfig, PlaceOrderParams, MultiOrderParams, CancelOrderParams, ModifyOrderParams, WithdrawParams, ApproveBuilderFeeParams, PrepareApproveBuilderFeeResult, SendApproveParams, MarketOrderParams, UpdateLeverageParams, BindTpslByOrderIdParams } from '../types';
+import type { OrderResponse, CancelResponse, ExchangeClientConfig, PlaceOrderParams, MultiOrderParams, CancelOrderParams, ModifyOrderParams, WithdrawParams, ApproveBuilderFeeParams, PrepareApproveBuilderFeeResult, SendApproveParams, MarketOrderParams, UpdateLeverageParams, BindTpslByOrderIdParams, UpdateIsolatedMarginParams } from '../types';
 /**
  * Client for executing trades on Hyperliquid (perpetuals only)
  * Only includes essential trading APIs as specified
@@ -71,6 +71,7 @@ export declare class ExchangeClient {
      * Modify an existing order
      */
     modifyOrder(params: ModifyOrderParams): Promise<any>;
+    updateIsolatedMargin(params: UpdateIsolatedMarginParams): Promise<any>;
     /**
      * Set referrer for 10% fee
      */

package/dist/client/exchange-client.js

@@ -451,6 +451,24 @@ class ExchangeClient {
             });
         });
     }
+    updateIsolatedMargin(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nonce = Date.now();
+            const assetIndex = yield this.symbolConversion.getAssetIndex(params.coin);
+            const action = {
+                type: constants_1.ExchangeType.UPDATE_ISOLATED_MARGIN,
+                asset: assetIndex,
+                isBuy: true,
+                ntli: (0, number_1.floatToInt)(params.value, 6), // 6 decimals
+            };
+            const signature = (0, signer_1.signL1AgentAction)(this.getAgentPrivateKey(), action, this.isTestnet, nonce);
+            return this.httpClient.exchange({
+                action,
+                nonce,
+                signature,
+            });
+        });
+    }
     /**
      * Set referrer for 10% fee
      */

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

@@ -1,4 +1,4 @@
-import type { AllMids, L2Book, Candle, WsOrder, WebData2, WsActiveAssetCtx, WsUserFills } from '../types';
+import type { AllMids, L2Book, Candle, WsOrder, WebData2, WsActiveAssetCtx, WsUserFills, WsClearinghouseState } from '../types';
 export interface WebSocketClientConfig {
     masterAddress?: string;
     isTestnet?: boolean;
@@ -43,6 +43,7 @@ export declare class WebSocketClient {
      * Disconnect from the WebSocket
      */
     disconnect(): void;
+    private getSubscriptionKey;
     /**
      * Subscribe to a channel
      */
@@ -84,6 +85,7 @@ export declare class WebSocketClient {
      * Includes positions, margin summary, open orders, and other user data
      */
     subscribeToWebData2(callback: SubscriptionCallback<WebData2>): Subscription;
+    subscribeToClearinghouseState(user: string | string[], callback: SubscriptionCallback<WsClearinghouseState>): Subscription;
     /**
      * Check if WebSocket is connected
      */
@@ -100,4 +102,10 @@ export declare class WebSocketClient {
      * Reset reconnection attempts and enable auto-reconnect
      */
     resetReconnectState(): void;
+    /**
+     * Handle application state change (for React Native)
+     * Call this method when the app state changes (e.g., active -> background, background -> active)
+     * @param state 'active' | 'background' | 'inactive'
+     */
+    handleAppStateChange(state: string): void;
 }

package/dist/client/websocket-client.js

@@ -77,8 +77,9 @@ class WebSocketClient {
                     this.pendingSubscriptions.forEach(({ message, callback }) => {
                         var _a;
                         if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN) {
+                            const subKey = this.getSubscriptionKey(message.subscription);
                             this.subscriptions.set(message.subscription.type, callback);
-                            this.activeSubscriptions.set(message.subscription.type, { message, callback });
+                            this.activeSubscriptions.set(subKey, { message, callback });
                             this.ws.send(JSON.stringify(Object.assign(Object.assign({}, message), { method: 'subscribe' })));
                         }
                     });
@@ -87,6 +88,7 @@ class WebSocketClient {
                     resolve();
                 };
                 this.ws.onmessage = (event) => {
+                    var _a;
                     try {
                         const data = JSON.parse(event.data);
                         // Handle pong response
@@ -95,9 +97,40 @@ class WebSocketClient {
                             return;
                         }
                         const type = data.channel;
-                        const callback = this.subscriptions.get(type);
-                        if (callback) {
-                            callback(data.data);
+                        // Iterate through active subscriptions to find matching ones
+                        let hasDispatched = false;
+                        for (const { message, callback } of this.activeSubscriptions.values()) {
+                            const subParams = message.subscription;
+                            if (subParams.type === type) {
+                                let isMatch = true;
+                                // Filter based on subscription parameters
+                                if (type === 'l2Book' && data.data.coin !== subParams.coin)
+                                    isMatch = false;
+                                if (type === 'trades' && ((_a = data.data[0]) === null || _a === void 0 ? void 0 : _a.coin) !== subParams.coin)
+                                    isMatch = false;
+                                if (type === 'candle' && (data.data.s !== subParams.coin || data.data.i !== subParams.interval))
+                                    isMatch = false;
+                                if (type === 'activeAssetCtx' && data.data.coin !== subParams.coin)
+                                    isMatch = false;
+                                // For user-specific data
+                                if (subParams.user) {
+                                    // If response data contains user, verify it matches
+                                    if (data.data && data.data.user && data.data.user.toLowerCase() !== subParams.user.toLowerCase()) {
+                                        isMatch = false;
+                                    }
+                                }
+                                if (isMatch) {
+                                    callback(data.data);
+                                    hasDispatched = true;
+                                }
+                            }
+                        }
+                        // Fallback to simple type map if no active subscription matched (backward compatibility or if activeSubscriptions missing)
+                        if (!hasDispatched) {
+                            const callback = this.subscriptions.get(type);
+                            if (callback) {
+                                callback(data.data);
+                            }
                         }
                     }
                     catch (error) {
@@ -113,8 +146,9 @@ class WebSocketClient {
                     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);
+                            this.activeSubscriptions.forEach((subscription) => {
+                                const subKey = this.getSubscriptionKey(subscription.message.subscription);
+                                const existingPending = this.pendingSubscriptions.find(sub => this.getSubscriptionKey(sub.message.subscription) === subKey);
                                 if (!existingPending) {
                                     this.pendingSubscriptions.push(subscription);
                                 }
@@ -178,15 +212,20 @@ class WebSocketClient {
         this.pendingSubscriptions = [];
         this.reconnectAttempts = 0; // 重置重连计数
     }
+    getSubscriptionKey(subscription) {
+        return JSON.stringify(subscription);
+    }
     /**
      * Subscribe to a channel
      */
     subscribe(message, callback) {
         var _a;
         const subscriptionData = { message, callback };
+        const subKey = this.getSubscriptionKey(message.subscription);
+        const type = message.subscription.type;
         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.subscriptions.set(type, callback);
+            this.activeSubscriptions.set(subKey, subscriptionData);
             this.ws.send(JSON.stringify(Object.assign(Object.assign({}, message), { method: 'subscribe' })));
         }
         else {
@@ -200,14 +239,23 @@ class WebSocketClient {
         return {
             unsubscribe: () => {
                 var _a;
-                const type = message.subscription.type;
-                this.subscriptions.delete(type);
-                this.activeSubscriptions.delete(type);
+                this.activeSubscriptions.delete(subKey);
+                // Only remove the global callback if no other active subscriptions use this channel type
+                let hasOtherSubs = false;
+                for (const sub of this.activeSubscriptions.values()) {
+                    if (sub.message.subscription.type === type) {
+                        hasOtherSubs = true;
+                        break;
+                    }
+                }
+                if (!hasOtherSubs) {
+                    this.subscriptions.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 !== type);
+                this.pendingSubscriptions = this.pendingSubscriptions.filter(sub => this.getSubscriptionKey(sub.message.subscription) !== subKey);
             },
         };
     }
@@ -296,6 +344,20 @@ class WebSocketClient {
             subscription: { type: 'webData2', user: this.config.masterAddress },
         }, callback);
     }
+    subscribeToClearinghouseState(user, callback) {
+        const users = Array.isArray(user) ? user : [user];
+        if (users.length === 0) {
+            throw new Error('user address is empty');
+        }
+        const subscriptions = users.map(u => this.subscribe({
+            subscription: { type: 'clearinghouseState', user: u || this.config.masterAddress },
+        }, callback));
+        return {
+            unsubscribe: () => {
+                subscriptions.forEach(sub => sub.unsubscribe());
+            }
+        };
+    }
     /**
      * Check if WebSocket is connected
      */
@@ -323,5 +385,32 @@ class WebSocketClient {
         this.reconnectAttempts = 0;
         this.isManualDisconnect = false;
     }
+    /**
+     * Handle application state change (for React Native)
+     * Call this method when the app state changes (e.g., active -> background, background -> active)
+     * @param state 'active' | 'background' | 'inactive'
+     */
+    handleAppStateChange(state) {
+        if (state === 'active') {
+            // App returned to foreground
+            if (!this.isConnected && !this.isManualDisconnect && this.config.autoReconnect) {
+                console.log('App returned to foreground, reconnecting WebSocket...');
+                this.reconnectAttempts = 0;
+                this.connect().catch(console.error);
+            }
+        }
+        else if (state === 'background') {
+            // App went to background
+            // Stop heartbeat and close connection to save resources
+            this.stopHeartbeat();
+            if (this.ws) {
+                // We don't set isManualDisconnect to true here because we want auto-reconnect 
+                // to kick in when we come back to 'active' state
+                this.ws.close();
+                this.ws = null;
+                console.log('App backgrounded: WebSocket disconnected to save resources');
+            }
+        }
+    }
 }
 exports.WebSocketClient = WebSocketClient;

package/dist/types/index.d.ts

@@ -96,6 +96,11 @@ export type Meta = {
     universe: AssetInfo[];
     marginTables: [number, MarginTable][];
 };
+export interface WsClearinghouseState {
+    dex: any;
+    user: string;
+    clearinghouseState: ClearinghouseState;
+}
 export interface ClearinghouseState {
     assetPositions: AssetPosition[];
     crossMaintenanceMarginUsed: string;
@@ -393,6 +398,10 @@ export interface CancelOrderParams {
     coin: string;
     oid: OrderId;
 }
+export interface UpdateIsolatedMarginParams {
+    coin: string;
+    value: number;
+}
 export interface ModifyOrderParams {
     oid: OrderId;
     coin: string;

package/dist/utils/number.d.ts

@@ -10,3 +10,4 @@
  * @returns The normalized string without trailing zeros
  */
 export declare function removeTrailingZeros(value: string): string;
+export declare function floatToInt(x: number, power: number): number;

package/dist/utils/number.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.removeTrailingZeros = removeTrailingZeros;
+exports.floatToInt = floatToInt;
 /**
  * Removes trailing zeros from a string representation of a number.
  * This is useful when working with price and size fields directly.
@@ -20,3 +21,10 @@ function removeTrailingZeros(value) {
         return '0';
     return normalized;
 }
+function floatToInt(x, power) {
+    const withDecimals = x * Math.pow(10, power);
+    if (Math.abs(Math.round(withDecimals) - withDecimals) >= 1e-3) {
+        throw new Error(`floatToInt causes rounding: ${x}`);
+    }
+    return Math.round(withDecimals);
+}

package/package.json

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