fix(perps): TP/SL orders disappear after creating a market order (#28073)

## **Description**

**Bug 1 (TAT-2636):** The WS-cache path in `updatePositionTPSL` was
missing an `isPositionTpsl` filter, causing it to cancel all trigger
reduce-only orders (including `normalTpsl` children of pending limit
orders) instead of only position-bound TP/SL orders. The REST fallback
already had the correct filter. This fix adds the matching
`isPositionTpsl` check to the cache path.

**Bug 2 (TAT-2835):** Fixing bug 1 exposed a display-side issue: the
position TP/SL display logic (both REST `getPositions` and WS cached
orders path in `extractTPSLFromOrders`) wasn't filtering by
`isPositionTpsl`, so when normalTpsl and positionTpsl orders coexist,
the position would show the limit order's TP/SL values instead of the
position-bound ones. Added `isPositionTpsl` filter to both display
paths.

## **Changelog**

CHANGELOG entry: Fixed a bug where placing a market order with TP/SL
would incorrectly cancel TP/SL orders belonging to existing pending
limit orders, and fixed position TP/SL display showing limit order
values instead of position-bound values.

## **Related issues**

Fixes:
[TAT-2636](https://consensyssoftware.atlassian.net/browse/TAT-2636)
Fixes:
[TAT-2835](https://consensyssoftware.atlassian.net/browse/TAT-2835)

## **Manual testing steps**

```gherkin
Feature: TP/SL orders from limit orders preserved after market order with TP/SL

  Scenario: user places a market order with TP/SL when a limit order with TP/SL already exists
    Given testnet mode is active
    And user has placed a BTC limit order at $50,000 with TP/SL (normalTpsl grouping)
    And the normalTpsl child orders are visible in open orders

    When user places a BTC market order with TP/SL (new position, triggers updatePositionTPSL)
    Then positionTpsl orders are created for the new position
    And the normalTpsl TP/SL children of the limit order are NOT cancelled
    And the position displays the market order's TP/SL values, not the limit order's
```

## **Screenshots/Recordings**

_Evidence available in task artifacts — will be added by reviewer if
needed._

### **Before**

<!-- Recipe fails at `verify-display-matches-position-tpsl`:
displayedTp=62500 (limit order value), expectedTp=74285 -->

### **After**

<!-- Recipe passes 12/12: displayedTp=74285 matches expectedTp=74285
(position-bound value) -->

## **Pre-merge author checklist**

- [x] I've followed [MetaMask Contributor
Docs](https://github.com/MetaMask/contributor-docs) and [MetaMask Mobile
Coding
Standards](https://github.com/MetaMask/metamask-mobile/blob/main/.github/guidelines/CODING_GUIDELINES.md).
- [x] I've completed the PR template to the best of my ability
- [x] I've included tests if applicable
- [x] I've documented my code using [JSDoc](https://jsdoc.app/) format
if applicable
- [x] I've applied the right labels on the PR (see [labeling
guidelines](https://github.com/MetaMask/metamask-mobile/blob/main/.github/guidelines/LABELING_GUIDELINES.md)).
Not required for external contributors.

## **Pre-merge reviewer checklist**

- [ ] I've manually tested the PR (e.g. pull and build branch, run the
app, test code being changed).
- [ ] I confirm that this PR addresses all acceptance criteria described
in the ticket it closes and includes the necessary testing evidence such
as recordings and or screenshots.

## **Recipe proof (before/after)**

| | Key assertion | displayedTp | expectedTp | Result |
|---|---|---|---|---|
| **Without fix** | `verify-display-matches-position-tpsl` | **62,500**
(limit order's TP) | 74,285 | **FAIL** |
| **With fix** | `verify-display-matches-position-tpsl` | **74,285**
(position's TP) | 74,285 | **PASS** |

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> **Medium Risk**
> Touches perps TP/SL cancellation and position display logic; incorrect
filtering could cancel the wrong orders or show wrong TP/SL values in
trading UI.
> 
> **Overview**
> Fixes TP/SL handling to distinguish *position-bound* TP/SL orders from
`normalTpsl` child orders.
> 
> `updatePositionTPSL` now applies the same `isPositionTpsl` filter when
using the WebSocket orders cache as it already did in the REST fallback,
preventing cancellation of limit-order TP/SL children. Position TP/SL
extraction/display is also updated (both `getPositions` and
`HyperLiquidSubscriptionService.#extractTPSLFromOrders`) to ignore
non-position-bound TP/SL when `UsePositionBoundTpsl` is enabled.
> 
> Adds/updates tests to cover mixed cached-order scenarios and ensures
`isPositionTpsl`/`triggerPrice` are propagated in subscription order
adaptation.
> 
> <sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit
371108e. Bugbot is set up for automated
code reviews on this repo. Configure
[here](https://www.cursor.com/dashboard/bugbot).</sup>
<!-- /CURSOR_SUMMARY -->


[TAT-2636]:
https://consensyssoftware.atlassian.net/browse/TAT-2636?atlOrigin=eyJpIjoiNWRkNTljNzYxNjVmNDY3MDlhMDU5Y2ZhYzA5YTRkZjUiLCJwIjoiZ2l0aHViLWNvbS1KU1cifQ

Author: abretonc7s

app/controllers/perps/providers/HyperLiquidProvider.test.ts

@@ -17,6 +17,7 @@ import { TradingReadinessCache } from '../services/TradingReadinessCache';
 import type {
   ClosePositionParams,
   DepositParams,
+  Order,
   PerpsPlatformDependencies,
   LiveDataConfig,
   OrderParams,
@@ -3570,6 +3571,138 @@ describe('HyperLiquidProvider', () => {
           ],
         });
       });
+
+      it('cache path: only cancels positionTpsl orders, not normalTpsl children of limit orders', async () => {
+        provider = createTestProvider({
+          initialAssetMapping: [['BTC', 0]],
+        });
+
+        // Simulate WS cache with mixed orders: normalTpsl children (isPositionTpsl: false)
+        // from a pending limit order AND positionTpsl orders (isPositionTpsl: true)
+        const cachedOrders: Order[] = [
+          {
+            orderId: '500',
+            symbol: 'BTC',
+            side: 'buy',
+            orderType: 'limit',
+            size: '0.01',
+            originalSize: '0.01',
+            price: '50000',
+            filledSize: '0',
+            remainingSize: '0.01',
+            status: 'open',
+            timestamp: 1000,
+            isTrigger: false,
+            reduceOnly: false,
+            isPositionTpsl: false,
+          },
+          {
+            orderId: '501',
+            symbol: 'BTC',
+            side: 'sell',
+            orderType: 'limit',
+            size: '0.01',
+            originalSize: '0.01',
+            price: '60000',
+            filledSize: '0',
+            remainingSize: '0.01',
+            status: 'open',
+            timestamp: 1001,
+            isTrigger: true,
+            reduceOnly: true,
+            isPositionTpsl: false,
+            detailedOrderType: 'Take Profit Limit',
+          },
+          {
+            orderId: '502',
+            symbol: 'BTC',
+            side: 'sell',
+            orderType: 'market',
+            size: '0.01',
+            originalSize: '0.01',
+            price: '40000',
+            filledSize: '0',
+            remainingSize: '0.01',
+            status: 'open',
+            timestamp: 1002,
+            isTrigger: true,
+            reduceOnly: true,
+            isPositionTpsl: false,
+            detailedOrderType: 'Stop Market',
+          },
+          {
+            orderId: '503',
+            symbol: 'BTC',
+            side: 'sell',
+            orderType: 'limit',
+            size: '0',
+            originalSize: '0',
+            price: '58000',
+            filledSize: '0',
+            remainingSize: '0',
+            status: 'open',
+            timestamp: 1003,
+            isTrigger: true,
+            reduceOnly: true,
+            isPositionTpsl: true,
+            detailedOrderType: 'Take Profit Limit',
+          },
+          {
+            orderId: '504',
+            symbol: 'BTC',
+            side: 'sell',
+            orderType: 'market',
+            size: '0',
+            originalSize: '0',
+            price: '42000',
+            filledSize: '0',
+            remainingSize: '0',
+            status: 'open',
+            timestamp: 1004,
+            isTrigger: true,
+            reduceOnly: true,
+            isPositionTpsl: true,
+            detailedOrderType: 'Stop Market',
+          },
+        ];
+
+        mockSubscriptionService.getOrdersCacheIfInitialized = jest
+          .fn()
+          .mockReturnValue(cachedOrders);
+
+        const mockCancel = jest.fn().mockResolvedValue({
+          status: 'ok',
+          response: { data: { statuses: ['success', 'success'] } },
+        });
+        mockClientService.getExchangeClient = jest.fn().mockReturnValue(
+          createMockExchangeClient({
+            cancel: mockCancel,
+            order: jest.fn().mockResolvedValue({
+              status: 'ok',
+              response: {
+                data: { statuses: [{ resting: { oid: '999' } }] },
+              },
+            }),
+          }),
+        );
+
+        mockWalletService.getUserAddressWithDefault.mockResolvedValue('0x123');
+
+        const result = await provider.updatePositionTPSL({
+          symbol: 'BTC',
+          takeProfitPrice: '60000',
+          stopLossPrice: '40000',
+        });
+
+        expect(result.success).toBe(true);
+        // Must cancel positionTpsl orders (503, 504) only — not normalTpsl children (501, 502)
+        expect(mockCancel).toHaveBeenCalledWith({
+          cancels: [
+            { a: 0, o: 503 },
+            { a: 0, o: 504 },
+          ],
+        });
+      });
     });
 
     describe('getAccountState error handling', () => {

app/controllers/perps/providers/HyperLiquidProvider.ts

@@ -4350,21 +4350,24 @@ export class HyperLiquidProvider implements PerpsProvider {
           { cachedOrdersCount: cachedOrders.length },
         );
 
-        // Filter using normalized Order type properties
-        // Note: Cached orders don't have isPositionTpsl, but we identify TP/SL orders by:
+        // Filter using normalized Order type properties, matching the REST fallback criteria:
+        // - symbol matches
         // - isTrigger === true
         // - reduceOnly === true
+        // - isPositionTpsl matches the configured mode (only cancel position-bound TP/SL,
+        //   not normalTpsl children that belong to pending limit orders)
         // - detailedOrderType contains 'Take Profit' or 'Stop'
         const tpslOrders = cachedOrders.filter(
           (order) =>
             order.symbol === symbol &&
             order.reduceOnly === true &&
             order.isTrigger === true &&
+            order.isPositionTpsl ===
+              Boolean(TP_SL_CONFIG.UsePositionBoundTpsl) &&
             order.detailedOrderType &&
             (order.detailedOrderType.includes('Take Profit') ||
               order.detailedOrderType.includes('Stop')),
         );
-
         cancelRequests = tpslOrders.map((order) => ({
           a: assetId,
           o: parseInt(order.orderId, 10),
@@ -4953,11 +4956,15 @@ export class HyperLiquidProvider implements PerpsProvider {
 
             // Find TP/SL orders for this position
             // First check direct trigger orders (raw SDK uses 'coin', adapted position uses 'symbol')
+            // Only match position-bound TP/SL orders when UsePositionBoundTpsl is enabled,
+            // to avoid picking up normalTpsl children from pending limit orders
             const positionOrders = allOrders.filter(
               (order) =>
                 order.coin === position.symbol &&
                 order.isTrigger &&
-                order.reduceOnly,
+                order.reduceOnly &&
+                order.isPositionTpsl ===
+                  Boolean(TP_SL_CONFIG.UsePositionBoundTpsl),
             );
 
             // Also check for parent orders that might have TP/SL children

app/controllers/perps/services/HyperLiquidSubscriptionService.test.ts

@@ -59,6 +59,10 @@ jest.mock('../utils/hyperLiquidAdapter', () => ({
     detailedOrderType: order.orderType || 'Limit',
     isTrigger: order.isTrigger ?? false,
     reduceOnly: order.reduceOnly ?? false,
+    triggerPrice: order.triggerPx,
+    ...(typeof order.isPositionTpsl === 'boolean'
+      ? { isPositionTpsl: order.isPositionTpsl }
+      : {}),
   })),
   adaptAccountStateFromSDK: jest.fn(() => ({
     availableBalance: '1000.00',

app/controllers/perps/services/HyperLiquidSubscriptionService.ts

@@ -732,6 +732,15 @@ export class HyperLiquidSubscriptionService {
         // This ensures consistency with raw SDK order processing which uses triggerPx
         const tpslPrice = order.triggerPrice ?? order.price;
         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
+          if (
+            TP_SL_CONFIG.UsePositionBoundTpsl &&
+            order.isPositionTpsl !== true
+          ) {
+            return;
+          }
+
           const isTakeProfit = order.detailedOrderType?.includes('Take Profit');
           const isStop = order.detailedOrderType?.includes('Stop');