@metamask-previews/perps-controller 10.0.0-preview-a42e8d0d2 → 10.0.0-preview-5a03e1b92

package/dist/services/HyperLiquidSubscriptionService.cjs

@@ -23,6 +23,7 @@ const errorUtils_js_1 = require("../utils/errorUtils.cjs");
 const hyperLiquidAdapter_js_1 = require("../utils/hyperLiquidAdapter.cjs");
 const hyperLiquidOrderBookProcessor_js_1 = require("../utils/hyperLiquidOrderBookProcessor.cjs");
 const marketDataTransform_js_1 = require("../utils/marketDataTransform.cjs");
+const orderTypes_js_1 = require("../utils/orderTypes.cjs");
 /**
  * Service for managing HyperLiquid WebSocket subscriptions
  * Implements singleton subscription architecture with reference counting
@@ -604,6 +605,29 @@ class HyperLiquidSubscriptionService {
     isPositionsCacheInitialized() {
         return __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_positionsCacheInitialized, "f");
     }
+    /**
+     * Get the cached positions for one DEX, or null when that DEX has published
+     * none this session.
+     *
+     * A DEX only enters this map once its `clearinghouseState` subscription has
+     * published, so `null` means the absence of a symbol proves nothing about
+     * whether a position exists there.
+     *
+     * Prefer this over `getCachedPositions()` when a decision depends on whether a
+     * specific symbol is absent. The aggregate is only rebuilt once *every*
+     * expected DEX has published (`#aggregateAndNotifySubscribers`), so after a
+     * reconnect — which resets `#initializedDexs` without clearing these caches —
+     * the aggregate can sit frozen at its pre-reconnect contents while this map
+     * keeps receiving per-DEX updates. Deciding "covered" from this map and then
+     * reading the symbol from the aggregate would mix a fresh answer with stale
+     * data.
+     *
+     * @param dexName - DEX identifier, or '' for the main DEX.
+     * @returns That DEX's cached positions, or null if it has not published.
+     */
+    getCachedPositionsForDex(dexName) {
+        return __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexPositionsCache, "f").get(dexName) ?? null;
+    }
     /**
      * Get cached positions from WebSocket subscription
      *
@@ -1169,7 +1193,11 @@ async function _HyperLiquidSubscriptionService_waitForDexDiscovery(timeoutMs = 5
         return '0';
     }
     return positions
-        .map((pos) => `${pos.symbol}:${pos.size}:${pos.entryPrice}:${pos.leverage.value}:${pos.takeProfitPrice ?? ''}:${pos.stopLossPrice ?? ''}:${pos.takeProfitCount}:${pos.stopLossCount}:${pos.unrealizedPnl}:${pos.returnOnEquity}:${pos.liquidationPrice ?? ''}:${pos.marginUsed || ''}`)
+        .map((pos) => `${pos.symbol}:${pos.size}:${pos.entryPrice}:${pos.leverage.value}:${pos.takeProfitPrice ?? ''}:${pos.stopLossPrice ?? ''}:${pos.takeProfitCount}:${pos.stopLossCount}:${pos.unrealizedPnl}:${pos.returnOnEquity}:${pos.liquidationPrice ?? ''}:${pos.marginUsed || ''}:${
+    // Trigger arrays are part of the emitted shape, so a standalone or
+    // partial trigger appearing/disappearing has to change the hash —
+    // otherwise subscribers never receive the updated arrays.
+    (0, orderTypes_js_1.hashTriggerOrders)(pos.takeProfitOrders)}:${(0, orderTypes_js_1.hashTriggerOrders)(pos.stopLossOrders)}`)
         .join('|');
 }, _HyperLiquidSubscriptionService_hashOrders = function _HyperLiquidSubscriptionService_hashOrders(orders) {
     if (!orders || orders.length === 0) {
@@ -1183,12 +1211,44 @@ async function _HyperLiquidSubscriptionService_waitForDexDiscovery(timeoutMs = 5
 }, _HyperLiquidSubscriptionService_extractTPSLFromOrders = function _HyperLiquidSubscriptionService_extractTPSLFromOrders(orders, positions, cachedProcessedOrders) {
     const tpslMap = new Map();
     const tpslCountMap = new Map();
+    // Complete per-symbol trigger order view, including quantity-scoped (partial)
+    // TP/SL orders that the scalar tpslMap prices cannot represent.
+    const triggerOrderMap = new Map();
+    const addTriggerOrder = (symbol, triggerOrder) => {
+        if (!triggerOrder) {
+            return;
+        }
+        const existing = triggerOrderMap.get(symbol) ?? {
+            takeProfitOrders: [],
+            stopLossOrders: [],
+        };
+        if (triggerOrder.direction === 'take_profit') {
+            existing.takeProfitOrders.push(triggerOrder);
+        }
+        else {
+            existing.stopLossOrders.push(triggerOrder);
+        }
+        triggerOrderMap.set(symbol, existing);
+    };
     // If cached processed orders provided, extract TP/SL from them directly
     if (cachedProcessedOrders) {
+        // Hoisted out of the per-order loop: this runs on every order-update tick.
+        const positionsBySymbol = new Map(positions.map((position) => [position.symbol, position]));
         cachedProcessedOrders.forEach((order) => {
             // Use triggerPrice for TP/SL (trigger condition price), falling back to price
             // This ensures consistency with raw SDK order processing which uses triggerPx
             const tpslPrice = order.triggerPrice ?? order.price;
+            // Collected before the position-bound filter below: partial TP/SL orders
+            // are standalone (not position-bound) and still belong to this view.
+            // A trigger that is another order's child does not — same rule as the
+            // REST path in HyperLiquidProvider.getPositions.
+            if (order.isTrigger && order.reduceOnly && !order.parentOrderId) {
+                addTriggerOrder(order.symbol, (0, orderTypes_js_1.buildPositionTriggerOrderFromOrder)({
+                    order,
+                    positionSize: positionsBySymbol.get(order.symbol)?.size ?? '0',
+                    entryPrice: positionsBySymbol.get(order.symbol)?.entryPrice,
+                }));
+            }
             if (order.isTrigger && tpslPrice) {
                 // When UsePositionBoundTpsl is enabled, only position-bound TP/SL orders
                 // should be shown on positions — skip normalTpsl children of limit orders
@@ -1246,10 +1306,25 @@ async function _HyperLiquidSubscriptionService_waitForDexDiscovery(timeoutMs = 5
                 }
             }
         });
-        return { tpslMap, tpslCountMap, processedOrders: cachedProcessedOrders };
+        return {
+            tpslMap,
+            tpslCountMap,
+            triggerOrderMap,
+            processedOrders: cachedProcessedOrders,
+        };
     }
     // Process raw SDK orders
     const processedOrders = [];
+    // TP/SL children of a pending parent order are listed both nested under the
+    // parent and as top-level entries. Map each child back to its parent so the
+    // converted order carries the link and the position trigger view can exclude
+    // them: they protect that order, not a position.
+    const parentIdByChildId = new Map();
+    orders.forEach((order) => {
+        order.children?.forEach((child) => {
+            parentIdByChildId.set(child.oid, order.oid);
+        });
+    });
     orders.forEach((order) => {
         let position;
         let positionForCoin;
@@ -1320,19 +1395,48 @@ async function _HyperLiquidSubscriptionService_waitForDexDiscovery(timeoutMs = 5
         }
         // Convert ALL open orders to Order format
         const convertedOrder = (0, hyperLiquidAdapter_js_1.adaptOrderFromSDK)(order, position ?? positionForCoin);
+        const parentOrderId = parentIdByChildId.get(order.oid);
+        if (parentOrderId !== undefined) {
+            convertedOrder.parentOrderId = parentOrderId.toString();
+        }
         processedOrders.push(convertedOrder);
+        if (convertedOrder.isTrigger &&
+            convertedOrder.reduceOnly &&
+            !convertedOrder.parentOrderId) {
+            addTriggerOrder(convertedOrder.symbol, (0, orderTypes_js_1.buildPositionTriggerOrderFromOrder)({
+                order: convertedOrder,
+                positionSize: (position ?? positionForCoin)?.size ?? '0',
+                entryPrice: (position ?? positionForCoin)?.entryPrice,
+            }));
+        }
     });
-    return { tpslMap, tpslCountMap, processedOrders };
-}, _HyperLiquidSubscriptionService_mergeTPSLIntoPositions = function _HyperLiquidSubscriptionService_mergeTPSLIntoPositions(positions, tpslMap, tpslCountMap) {
+    return { tpslMap, tpslCountMap, triggerOrderMap, processedOrders };
+}, _HyperLiquidSubscriptionService_mergeTPSLIntoPositions = function _HyperLiquidSubscriptionService_mergeTPSLIntoPositions(positions, tpslMap, tpslCountMap, triggerOrderMap) {
     return positions.map((position) => {
         const tpsl = tpslMap.get(position.symbol) ?? {};
         const tpslCount = tpslCountMap.get(position.symbol) ?? {};
+        const triggerOrders = triggerOrderMap?.get(position.symbol);
+        const takeProfitOrders = triggerOrders?.takeProfitOrders ?? [];
+        const stopLossOrders = triggerOrders?.stopLossOrders ?? [];
         return {
             ...position,
             takeProfitPrice: tpsl.takeProfitPrice ?? undefined,
             stopLossPrice: tpsl.stopLossPrice ?? undefined,
-            takeProfitCount: tpslCount.takeProfitCount ?? 0,
-            stopLossCount: tpslCount.stopLossCount ?? 0,
+            // Counts come from the same arrays as the REST path, so both transports
+            // report one definition. Orders whose placement type the exchange did
+            // not name (HyperLiquid's ambiguous 'Trigger') are absent from both,
+            // where the legacy count included them.
+            // Keyed on the map, not on this symbol's entry: a symbol with no
+            // entry has no triggers, and falling back to the legacy count there
+            // would report a count beside an empty array.
+            takeProfitCount: triggerOrderMap
+                ? takeProfitOrders.length
+                : (tpslCount.takeProfitCount ?? 0),
+            stopLossCount: triggerOrderMap
+                ? stopLossOrders.length
+                : (tpslCount.stopLossCount ?? 0),
+            takeProfitOrders,
+            stopLossOrders,
         };
     });
 }, _HyperLiquidSubscriptionService_aggregateAccountStates = function _HyperLiquidSubscriptionService_aggregateAccountStates() {
@@ -1869,10 +1973,16 @@ async function _HyperLiquidSubscriptionService_createClearinghouseSubscription(u
                 const cachedOrders = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexOrdersCache, "f").get(cacheKey) ?? [];
                 // Re-extract TP/SL from cached orders for the new positions
                 // This ensures TP/SL data persists across clearinghouseState updates
-                let positionsWithTPSL = positions;
+                // Default the trigger arrays so "no triggers" and "not streamed yet"
+                // look the same to consumers as they do on the REST path.
+                let positionsWithTPSL = positions.map((position) => ({
+                    ...position,
+                    takeProfitOrders: position.takeProfitOrders ?? [],
+                    stopLossOrders: position.stopLossOrders ?? [],
+                }));
                 if (cachedOrders.length > 0) {
-                    const { tpslMap, tpslCountMap } = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_extractTPSLFromOrders).call(this, [], positions, cachedOrders);
-                    positionsWithTPSL = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_mergeTPSLIntoPositions).call(this, positions, tpslMap, tpslCountMap);
+                    const { tpslMap, tpslCountMap, triggerOrderMap } = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_extractTPSLFromOrders).call(this, [], positions, cachedOrders);
+                    positionsWithTPSL = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_mergeTPSLIntoPositions).call(this, positions, tpslMap, tpslCountMap, triggerOrderMap);
                 }
                 // Update account state
                 const accountState = (0, hyperLiquidAdapter_js_1.adaptAccountStateFromSDK)(data.clearinghouseState);
@@ -1953,12 +2063,12 @@ async function _HyperLiquidSubscriptionService_createOpenOrdersSubscription(user
                 // Get cached positions for TP/SL processing
                 const cachedPositions = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexPositionsCache, "f").get(cacheKey) ?? [];
                 // Extract TP/SL and process orders
-                const { tpslMap, tpslCountMap, processedOrders: orders, } = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_extractTPSLFromOrders).call(this, data.orders, cachedPositions);
+                const { tpslMap, tpslCountMap, triggerOrderMap, processedOrders: orders, } = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_extractTPSLFromOrders).call(this, data.orders, cachedPositions);
                 // Update orders cache with processed orders
                 __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexOrdersCache, "f").set(cacheKey, orders);
                 // Update positions with TP/SL if we have positions
                 if (cachedPositions.length > 0) {
-                    const positionsWithTPSL = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_mergeTPSLIntoPositions).call(this, cachedPositions, tpslMap, tpslCountMap);
+                    const positionsWithTPSL = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_mergeTPSLIntoPositions).call(this, cachedPositions, tpslMap, tpslCountMap, triggerOrderMap);
                     __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexPositionsCache, "f").set(cacheKey, positionsWithTPSL);
                 }
                 // Mark this DEX as initialized (has sent first data)