MetaMask
diff --git a/‎ui/components/app/perps/utils.ts‎
Lines changed: 5 additions & 0 deletions b/‎ui/components/app/perps/utils.ts‎
Lines changed: 5 additions & 0 deletions
diff --git a/‎ui/components/app/perps/utils/index.ts‎
Lines changed: 2 additions & 0 deletions b/‎ui/components/app/perps/utils/index.ts‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎ui/components/app/perps/utils/orderUtils.test.ts‎
Lines changed: 216 additions & 2 deletions b/‎ui/components/app/perps/utils/orderUtils.test.ts‎
Lines changed: 216 additions & 2 deletions
diff --git a/‎ui/components/app/perps/utils/orderUtils.ts‎
Lines changed: 102 additions & 2 deletions b/‎ui/components/app/perps/utils/orderUtils.ts‎
Lines changed: 102 additions & 2 deletions
@@ -12,6 +12,11 @@ import {
   PERPS_CONSTANTS,
 } from './constants';
 
+// Re-exported here because callers importing `'../../components/app/perps/utils'`
+// resolve to this file (TypeScript prefers sibling `utils.ts` over the
+// `utils/index.ts` barrel). Keep the surface area in sync with `utils/index.ts`.
+export { willFlipPosition } from './utils/orderUtils';
+
 /**
  * Extract display name from symbol (strips DEX prefix for HIP-3 markets)
  * e.g., "xyz:TSLA" -> "TSLA", "BTC" -> "BTC"
 
@@ -21,6 +21,8 @@ export {
   shouldDisplayOrderInMarketDetailsOrders,
   buildDisplayOrdersWithSyntheticTpsl,
   isOrderAssociatedWithFullPosition,
+  derivePositionTpslPricesFromOrders,
+  willFlipPosition,
   formatOrderLabel,
 } from './orderUtils';
 
 
@@ -1,9 +1,11 @@
-import type { Order, Position } from '@metamask/perps-controller';
+import type { Order, OrderParams, Position } from '@metamask/perps-controller';
 import {
   isOrderAssociatedWithFullPosition,
   shouldDisplayOrderInMarketDetailsOrders,
   buildDisplayOrdersWithSyntheticTpsl,
   normalizeMarketDetailsOrders,
+  derivePositionTpslPricesFromOrders,
+  willFlipPosition,
   formatOrderLabel,
 } from './orderUtils';
 
@@ -66,7 +68,7 @@ describe('orderUtils', () => {
       expect(isOrderAssociatedWithFullPosition(order, position)).toBe(false);
     });
 
-    it('returns false when isPositionTpsl is explicitly false', () => {
+    it('returns false when isPositionTpsl is explicitly false on a non-trigger order', () => {
       const order = makeOrder({
         reduceOnly: true,
         isPositionTpsl: false,
@@ -78,6 +80,27 @@ describe('orderUtils', () => {
       expect(isOrderAssociatedWithFullPosition(order, position)).toBe(false);
     });
 
+    it('returns false for a TP/SL trigger with isPositionTpsl=false even when size matches the position (limit-order child)', () => {
+      // A limit-order's TP/SL children also carry isPositionTpsl=false with
+      // isTrigger=true. If the limit size coincidentally equals the active
+      // position size, size-matching would misclassify them as full-position
+      // and hide them from the Orders section. The explicit `false` flag is
+      // authoritative — trust the provider over size coincidence.
+      const order = makeOrder({
+        reduceOnly: true,
+        isPositionTpsl: false,
+        isTrigger: true,
+        symbol: 'ETH',
+        side: 'sell',
+        size: '1.0',
+        originalSize: '1.0',
+        triggerPrice: '3300',
+        detailedOrderType: 'Take Profit Limit',
+      });
+      const position = makePosition({ symbol: 'ETH', size: '1.0' });
+      expect(isOrderAssociatedWithFullPosition(order, position)).toBe(false);
+    });
+
     it('returns true when reduce-only order matches full position size (sell closing long)', () => {
       const order = makeOrder({
         reduceOnly: true,
@@ -165,6 +188,197 @@ describe('orderUtils', () => {
       });
       expect(shouldDisplayOrderInMarketDetailsOrders(positionTpsl)).toBe(false);
     });
+
+    it('excludes zero-size reduce-only trigger orders matching the position even without isPositionTpsl flag', () => {
+      // Hyperliquid positionTPSL trigger orders carry size '0' (whole-position
+      // trigger). WebSocket order updates omit isPositionTpsl, so the UI must
+      // still recognise the order as full-position when size is zero and the
+      // trigger matches the active position.
+      const positionTpslNoFlag = makeOrder({
+        reduceOnly: true,
+        isTrigger: true,
+        symbol: 'ETH',
+        side: 'sell',
+        size: '0',
+        originalSize: '0',
+        triggerPrice: '3200.00',
+        detailedOrderType: 'Take Profit Market',
+      });
+      const position = makePosition({ symbol: 'ETH', size: '1.0' });
+      expect(
+        shouldDisplayOrderInMarketDetailsOrders(positionTpslNoFlag, position),
+      ).toBe(false);
+    });
+
+    it('keeps a flag-less zero-size reduce-only trigger visible when no matching position exists', () => {
+      const orphanTpsl = makeOrder({
+        reduceOnly: true,
+        isTrigger: true,
+        symbol: 'ETH',
+        side: 'sell',
+        size: '0',
+        originalSize: '0',
+        triggerPrice: '3200.00',
+      });
+      expect(shouldDisplayOrderInMarketDetailsOrders(orphanTpsl)).toBe(true);
+    });
+
+    it('keeps a flag-less zero-size reduce-only order without isTrigger visible (cannot infer position binding)', () => {
+      const zeroSizeNonTrigger = makeOrder({
+        reduceOnly: true,
+        symbol: 'ETH',
+        side: 'sell',
+        size: '0',
+        originalSize: '0',
+      });
+      const position = makePosition({ symbol: 'ETH', size: '1.0' });
+      expect(
+        shouldDisplayOrderInMarketDetailsOrders(zeroSizeNonTrigger, position),
+      ).toBe(true);
+    });
+  });
+
+  describe('willFlipPosition', () => {
+    const makeParams = (overrides: Partial<OrderParams> = {}): OrderParams =>
+      ({
+        symbol: 'ETH',
+        isBuy: false,
+        size: '2.0',
+        orderType: 'market',
+        ...overrides,
+      }) as OrderParams;
+
+    it('returns false for reduce-only orders', () => {
+      expect(
+        willFlipPosition(
+          makePosition({ size: '1.0' }),
+          makeParams({ reduceOnly: true }),
+        ),
+      ).toBe(false);
+    });
+
+    it('returns false for limit orders', () => {
+      expect(
+        willFlipPosition(
+          makePosition({ size: '1.0' }),
+          makeParams({ orderType: 'limit' }),
+        ),
+      ).toBe(false);
+    });
+
+    it('returns false when order direction matches position direction', () => {
+      expect(
+        willFlipPosition(
+          makePosition({ size: '1.0' }),
+          makeParams({ isBuy: true, size: '5.0' }),
+        ),
+      ).toBe(false);
+    });
+
+    it('returns true when opposing market order exceeds the position size', () => {
+      expect(
+        willFlipPosition(
+          makePosition({ size: '1.0' }),
+          makeParams({ isBuy: false, size: '2.0' }),
+        ),
+      ).toBe(true);
+    });
+
+    it('returns false when opposing market order matches the position size (full close, no flip)', () => {
+      expect(
+        willFlipPosition(
+          makePosition({ size: '1.0' }),
+          makeParams({ isBuy: false, size: '1.0' }),
+        ),
+      ).toBe(false);
+    });
+
+    it('strips thousand separators from position and order sizes before comparing', () => {
+      expect(
+        willFlipPosition(
+          makePosition({ size: '1,234.5' }),
+          makeParams({ isBuy: false, size: '2,000' }),
+        ),
+      ).toBe(true);
+      expect(
+        willFlipPosition(
+          makePosition({ size: '1,234.5' }),
+          makeParams({ isBuy: false, size: '500' }),
+        ),
+      ).toBe(false);
+    });
+
+    it('returns false when the current position size is zero (no phantom direction)', () => {
+      expect(
+        willFlipPosition(
+          makePosition({ size: '0' }),
+          makeParams({ isBuy: false, size: '1.0' }),
+        ),
+      ).toBe(false);
+      expect(
+        willFlipPosition(
+          makePosition({ size: '0' }),
+          makeParams({ isBuy: true, size: '1.0' }),
+        ),
+      ).toBe(false);
+    });
+  });
+
+  describe('derivePositionTpslPricesFromOrders', () => {
+    it('returns empty when no position is provided', () => {
+      const order = makeOrder({
+        reduceOnly: true,
+        isTrigger: true,
+        isPositionTpsl: true,
+        triggerPrice: '3200',
+        detailedOrderType: 'Take Profit Market',
+      });
+      expect(derivePositionTpslPricesFromOrders([order])).toEqual({});
+    });
+
+    it('returns TP and SL prices from positionTPSL trigger orders matching the position', () => {
+      const position = makePosition({ symbol: 'ETH', size: '1.0' });
+      const tp = makeOrder({
+        orderId: 'tp',
+        reduceOnly: true,
+        isTrigger: true,
+        isPositionTpsl: true,
+        symbol: 'ETH',
+        side: 'sell',
+        triggerPrice: '3200',
+        detailedOrderType: 'Take Profit Market',
+      });
+      const sl = makeOrder({
+        orderId: 'sl',
+        reduceOnly: true,
+        isTrigger: true,
+        symbol: 'ETH',
+        side: 'sell',
+        size: '0',
+        originalSize: '0',
+        triggerPrice: '2800',
+        detailedOrderType: 'Stop Market',
+      });
+      expect(derivePositionTpslPricesFromOrders([tp, sl], position)).toEqual({
+        takeProfitPrice: '3200',
+        stopLossPrice: '2800',
+      });
+    });
+
+    it('ignores non-positionTPSL trigger orders', () => {
+      const position = makePosition({ symbol: 'ETH', size: '1.0' });
+      const limitTrigger = makeOrder({
+        reduceOnly: false,
+        isTrigger: true,
+        symbol: 'ETH',
+        side: 'sell',
+        triggerPrice: '3300',
+        detailedOrderType: 'Stop Limit',
+      });
+      expect(
+        derivePositionTpslPricesFromOrders([limitTrigger], position),
+      ).toEqual({});
+    });
   });
 
   describe('buildDisplayOrdersWithSyntheticTpsl', () => {
 
@@ -1,6 +1,6 @@
 import BigNumber from 'bignumber.js';
 import { capitalize } from 'lodash';
-import type { Order, Position } from '@metamask/perps-controller';
+import type { Order, OrderParams, Position } from '@metamask/perps-controller';
 
 const FULL_POSITION_SIZE_TOLERANCE = new BigNumber('0.00000001');
 const ORDER_PRICE_MATCH_TOLERANCE = new BigNumber('0.00000001');
@@ -153,19 +153,119 @@ export const isOrderAssociatedWithFullPosition = (
     return false;
   }
 
+  // Only fall back to size matching when the provider did not send the flag.
+  // An explicit `isPositionTpsl: false` (e.g. normalTpsl grouping from a
+  // limit-order's TP/SL children) is authoritative — do not size-match,
+  // otherwise a limit-order TP/SL whose size coincidentally equals the
+  // current position would be misclassified as full-position.
   if (order.isPositionTpsl === false) {
     return false;
   }
 
   const orderSize = getAbsoluteOrderSize(order);
   const positionSize = getAbsolutePositionSize(position);
-  if (!orderSize || !positionSize) {
+
+  // Hyperliquid positionTPSL trigger orders may also be placed with size 0
+  // (the trigger acts on whatever the current position size is). When the
+  // adapter cannot back-fill the size, treat a reduce-only trigger on a
+  // matching position+closing-side as position-bound.
+  if (!orderSize) {
+    return order.isTrigger === true;
+  }
+
+  if (!positionSize) {
     return false;
   }
 
   return orderSize.minus(positionSize).abs().lte(FULL_POSITION_SIZE_TOLERANCE);
 };
 
+/**
+ * Returns true when a non-reduce-only market order is large enough to flip the
+ * current position (close the existing side and open the opposite side).
+ * Mirrors `app/components/UI/Perps/utils/orderUtils.ts:willFlipPosition` on
+ * mobile so the order-entry page can replicate the two-step market+TPSL
+ * flow that yields `grouping: 'positionTpsl'` on Hyperliquid.
+ *
+ * @param currentPosition - The existing position
+ * @param orderParams - The order about to be submitted
+ * @returns Whether the order will flip the position
+ */
+export const willFlipPosition = (
+  currentPosition: Position,
+  orderParams: OrderParams,
+): boolean => {
+  if (orderParams.reduceOnly === true) {
+    return false;
+  }
+  if (orderParams.orderType !== 'market') {
+    return false;
+  }
+  // Hyperliquid position/order size strings can carry thousand separators
+  // (e.g. `'1,234.5'`); strip commas before parseFloat so the magnitude
+  // comparison stays correct for large positions.
+  const currentPositionSize = parseFloat(
+    currentPosition.size.replaceAll(',', ''),
+  );
+  // A zero-size position is not a position — short-circuit so a sell market
+  // does not match the phantom `'short'` direction below and falsely report
+  // "no flip". The caller also guards on size === 0, but keep this safe in
+  // isolation.
+  if (currentPositionSize === 0 || !Number.isFinite(currentPositionSize)) {
+    return false;
+  }
+  const positionDirection = currentPositionSize > 0 ? 'long' : 'short';
+  const orderDirection = orderParams.isBuy ? 'long' : 'short';
+  if (positionDirection === orderDirection) {
+    return false;
+  }
+  const orderSize = parseFloat(orderParams.size.replaceAll(',', ''));
+  return orderSize > Math.abs(currentPositionSize);
+};
+
+/**
+ * Derives the take-profit and stop-loss prices for the active position by
+ * inspecting full-position reduce-only trigger orders. Used as a UI fallback
+ * when the controller fails to populate `position.takeProfitPrice` /
+ * `position.stopLossPrice` (e.g. Hyperliquid WebSocket order updates that
+ * omit `isPositionTpsl`).
+ *
+ * @param orders - The orders to inspect
+ * @param position - The current position
+ * @returns Object with takeProfitPrice / stopLossPrice when discoverable
+ */
+export const derivePositionTpslPricesFromOrders = (
+  orders: Order[],
+  position?: Position,
+): { takeProfitPrice?: string; stopLossPrice?: string } => {
+  if (!position) {
+    return {};
+  }
+
+  const result: { takeProfitPrice?: string; stopLossPrice?: string } = {};
+  for (const order of orders) {
+    if (
+      !order.isTrigger ||
+      !isOrderAssociatedWithFullPosition(order, position)
+    ) {
+      continue;
+    }
+
+    const triggerPrice = getOrderTriggerPrice(order)?.toFixed();
+    if (!triggerPrice) {
+      continue;
+    }
+
+    const detailedType = (order.detailedOrderType ?? '').toLowerCase();
+    if (!result.takeProfitPrice && detailedType.includes('take profit')) {
+      result.takeProfitPrice = triggerPrice;
+    } else if (!result.stopLossPrice && detailedType.includes('stop')) {
+      result.stopLossPrice = triggerPrice;
+    }
+  }
+  return result;
+};
+
 /**
  * Determines whether an order should be shown in Market Details > Orders
  * (the perps asset / position detail screen).