fix(perps): pass position in TP/SL onConfirm to avoid No position found errors (MetaMask#27409)

<!--
Please submit this PR as a draft initially.
Do not mark it as "Ready for review" until the template has been
completely filled out, and PR status checks have passed at least once.
-->

## **Description**

When editing Take Profit / Stop Loss (TP/SL) for an existing Perps
position, the `onConfirm` callback relied on a ref
(`currentPositionRef.current`) to get the position at execution time. If
the position was updated during navigation (e.g. via WebSocket), the ref
could be stale, causing "No position found" errors when the user
confirmed TP/SL.

This change extends the TP/SL `onConfirm` signature to accept an
optional first argument `position`. The TPSL view now passes the
position from route params into `onConfirm`, and the market-details flow
uses that passed position when present, falling back to the ref. Order
flow and market-tabs callbacks were updated to match the new signature
(they ignore the position argument). This ensures the callback always
receives the correct position and avoids the stale-ref error.

## **Changelog**

CHANGELOG entry: null

## **Related issues**

Fixes: https://consensyssoftware.atlassian.net/browse/TAT-2369

## **Manual testing steps**

```gherkin
Feature: Perps TP/SL confirmation

  Scenario: user confirms TP/SL for an existing position without "No position found" error
    Given user has an open Perps position and navigates to edit TP/SL (market details or market tabs)
    And the position data may have been updated (e.g. via WebSocket) before user taps Confirm

    When user sets Take Profit and/or Stop Loss and taps Confirm

    Then TP/SL is updated successfully and no "No position found" error is shown
```

## **Screenshots/Recordings**

N/A (behavioral fix; no UI change).

### **Before**

<!-- [screenshots/recordings] -->

### **After**

<!-- [screenshots/recordings] -->

## **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.


<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> **Medium Risk**
> Changes the `PerpsTPSL` route `onConfirm` callback signature/return
type and updates multiple callers, so mismatches could break TP/SL
confirmation flows if any usage is missed.
> 
> **Overview**
> Fixes a TP/SL confirmation race by **passing the `position` from
`PerpsTPSLView` into the route `onConfirm` callback**, and having
`PerpsMarketDetailsView` prefer that position (falling back to
`currentPositionRef`) before calling `handleUpdateTPSL`.
> 
> Updates the `PerpsTPSL` navigation type and all known callers
(`PerpsOrderView`, `PerpsMarketTabs`) to match the new `(position?, tp?,
sl?, trackingData?)` signature, adjusts TPSL view tests accordingly, and
adds a market-details test asserting `{ success: false }` when confirm
runs after the position is cleared.
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
ee47f9c. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: michalconsensys

app/components/UI/Perps/Views/PerpsMarketDetailsView/PerpsMarketDetailsView.test.tsx

@@ -1939,6 +1939,69 @@ describe('PerpsMarketDetailsView', () => {
 
       expect(getByText('Geo Block Tooltip')).toBeOnTheScreen();
     });
+
+    it('returns failure when TPSL onConfirm runs after position is cleared', async () => {
+      mockNavigate.mockClear();
+
+      const existingPosition = {
+        symbol: 'BTC',
+        size: '0.5',
+        entryPrice: '50000',
+        leverage: { value: 10, type: 'isolated' as const },
+        marginUsed: '5000',
+        unrealizedPnl: '100',
+        returnOnEquity: '0.02',
+        liquidationPrice: '45000',
+      };
+
+      mockUseHasExistingPosition.mockReturnValue({
+        hasPosition: true,
+        isLoading: false,
+        error: null,
+        existingPosition,
+        refreshPosition: jest.fn(),
+        positionOpenedTimestamp: undefined,
+      });
+
+      const viewTree = (
+        <PerpsConnectionProvider>
+          <PerpsMarketDetailsView />
+        </PerpsConnectionProvider>
+      );
+
+      const { getByTestId, rerender } = renderWithProvider(viewTree, {
+        state: initialState,
+      });
+
+      fireEvent.press(getByTestId('perps-position-card-auto-close-button'));
+
+      const tpslNavigateCall = mockNavigate.mock.calls.find(
+        (call) => call[0] === 'PerpsTPSL',
+      );
+      expect(tpslNavigateCall).toBeTruthy();
+      const onConfirm = (
+        tpslNavigateCall as [
+          string,
+          { onConfirm: (...args: unknown[]) => Promise<{ success: boolean }> },
+        ]
+      )[1].onConfirm;
+
+      mockUseHasExistingPosition.mockReturnValue({
+        hasPosition: false,
+        isLoading: false,
+        error: null,
+        existingPosition: null,
+        refreshPosition: jest.fn(),
+        positionOpenedTimestamp: undefined,
+      });
+
+      rerender(viewTree);
+
+      await act(async () => {
+        const result = await onConfirm(undefined, undefined, undefined);
+        expect(result).toEqual({ success: false });
+      });
+    });
   });
 
   describe('Notification tooltip functionality', () => {

app/components/UI/Perps/Views/PerpsMarketDetailsView/PerpsMarketDetailsView.tsx

@@ -776,19 +776,18 @@ const PerpsMarketDetailsView: React.FC<PerpsMarketDetailsViewProps> = () => {
       initialTakeProfitPrice: existingPosition.takeProfitPrice,
       initialStopLossPrice: existingPosition.stopLossPrice,
       onConfirm: async (
+        positionFromRoute?: Position,
         takeProfitPrice?: string,
         stopLossPrice?: string,
         trackingData?: TPSLTrackingData,
       ) => {
-        // Use ref to get CURRENT position at execution time, not the closure-captured position
-        // This prevents "No position found" errors when the position updates during navigation
-        const currentPosition = currentPositionRef.current;
-        if (!currentPosition) {
+        // Prefer position passed from TPSL view (from route params); fallback to ref to avoid "No position found" when ref is stale
+        const positionToUse = positionFromRoute ?? currentPositionRef.current;
+        if (!positionToUse) {
           return { success: false };
         }
-        // Return value checked for consistency - error toast is shown internally by hook
         const result = await handleUpdateTPSL(
-          currentPosition,
+          positionToUse,
           takeProfitPrice,
           stopLossPrice,
           trackingData,

app/components/UI/Perps/Views/PerpsOrderView/PerpsOrderView.tsx

@@ -761,9 +761,12 @@ const PerpsOrderViewContentBase: React.FC<PerpsOrderViewContentProps> = ({
       initialStopLossPrice: orderForm.stopLossPrice,
       amount: orderForm.amount,
       szDecimals: marketData?.szDecimals,
-      onConfirm: async (takeProfitPrice?: string, stopLossPrice?: string) => {
-        // Use the same clearing approach as the "Off" button
-        // If values are undefined or empty, ensure they're cleared properly
+      onConfirm: async (
+        _position?: Position,
+        takeProfitPrice?: string,
+        stopLossPrice?: string,
+      ) => {
+        // Order flow: no position; just persist TP/SL in form state
         const tpToSet = takeProfitPrice || undefined;
         const slToSet = stopLossPrice || undefined;
 

app/components/UI/Perps/Views/PerpsTPSLView/PerpsTPSLView.test.tsx

@@ -489,15 +489,20 @@ describe('PerpsTPSLView', () => {
         fireEvent.press(setButton);
       });
 
-      expect(mockOnConfirm).toHaveBeenCalledWith('3150.00', '2850.00', {
-        direction: 'long',
-        source: PERPS_EVENT_VALUE.RISK_MANAGEMENT_SOURCE.TRADE_SCREEN,
-        positionSize: 0,
-        takeProfitPercentage: undefined,
-        stopLossPercentage: undefined,
-        isEditingExistingPosition: false,
-        entryPrice: 3000,
-      });
+      expect(mockOnConfirm).toHaveBeenCalledWith(
+        undefined,
+        '3150.00',
+        '2850.00',
+        {
+          direction: 'long',
+          source: PERPS_EVENT_VALUE.RISK_MANAGEMENT_SOURCE.TRADE_SCREEN,
+          positionSize: 0,
+          takeProfitPercentage: undefined,
+          stopLossPercentage: undefined,
+          isEditingExistingPosition: false,
+          entryPrice: 3000,
+        },
+      );
     });
 
     it('calls onConfirm with undefined when values are empty', async () => {
@@ -510,15 +515,20 @@ describe('PerpsTPSLView', () => {
         fireEvent.press(setButton);
       });
 
-      expect(mockOnConfirm).toHaveBeenCalledWith(undefined, undefined, {
-        direction: 'long',
-        source: PERPS_EVENT_VALUE.RISK_MANAGEMENT_SOURCE.TRADE_SCREEN,
-        positionSize: 0,
-        takeProfitPercentage: undefined,
-        stopLossPercentage: undefined,
-        isEditingExistingPosition: false,
-        entryPrice: 3000,
-      });
+      expect(mockOnConfirm).toHaveBeenCalledWith(
+        undefined,
+        undefined,
+        undefined,
+        {
+          direction: 'long',
+          source: PERPS_EVENT_VALUE.RISK_MANAGEMENT_SOURCE.TRADE_SCREEN,
+          positionSize: 0,
+          takeProfitPercentage: undefined,
+          stopLossPercentage: undefined,
+          isEditingExistingPosition: false,
+          entryPrice: 3000,
+        },
+      );
     });
 
     it('dismisses keypad before confirming when input is focused', async () => {

app/components/UI/Perps/Views/PerpsTPSLView/PerpsTPSLView.tsx

@@ -400,7 +400,13 @@ const PerpsTPSLView: React.FC = () => {
         isEditingExistingPosition,
         entryPrice: effectiveEntryPrice,
       };
-      await onConfirm(parseTakeProfitPrice, parseStopLossPrice, trackingData);
+      // Pass position from route params so the callback always has the correct position (avoids "No position found" when parent ref is stale)
+      await onConfirm(
+        position,
+        parseTakeProfitPrice,
+        parseStopLossPrice,
+        trackingData,
+      );
       navigation.goBack();
     } finally {
       setIsUpdating(false);

app/components/UI/Perps/components/PerpsMarketTabs/PerpsMarketTabs.tsx

@@ -30,8 +30,9 @@ import styleSheet from './PerpsMarketTabs.styles';
 import {
   OrderDirection,
   PERPS_CONSTANTS,
-  type Position,
   type Order,
+  type Position,
+  type TPSLTrackingData,
 } from '@metamask/perps-controller';
 import { usePerpsMarketStats } from '../../hooks/usePerpsMarketStats';
 import {
@@ -329,9 +330,13 @@ const PerpsMarketTabs: React.FC<PerpsMarketTabsProps> = ({
       position,
       initialTakeProfitPrice: position.takeProfitPrice,
       initialStopLossPrice: position.stopLossPrice,
-      onConfirm: async () => {
-        // TP/SL is set directly on the position, no need to handle here
-        // The position will update via WebSocket
+      onConfirm: async (
+        _position?: Position,
+        _takeProfitPrice?: string,
+        _stopLossPrice?: string,
+        _trackingData?: TPSLTrackingData,
+      ) => {
+        // TP/SL is set directly on the position via WebSocket; callback signature matches PerpsTPSL route type
       },
     });
   }, [position, currentPrice, navigation]);

app/components/UI/Perps/types/navigation.ts

@@ -180,11 +180,16 @@ export interface PerpsNavigationParamList extends ParamListBase {
     limitPrice?: string;
     amount?: string; // For new orders - USD amount to calculate position size for P&L
     szDecimals?: number; // For new orders - asset decimal precision for P&L
+    /**
+     * Called when user confirms TP/SL. First arg is position when editing existing position (avoids "No position found" from stale ref).
+     * Signature: (position?, takeProfitPrice?, stopLossPrice?, trackingData?) so both edit-flow and order-flow can use it.
+     */
     onConfirm: (
+      position?: Position,
       takeProfitPrice?: string,
       stopLossPrice?: string,
       trackingData?: TPSLTrackingData,
-    ) => Promise<void>;
+    ) => Promise<{ success: boolean } | void>;
   };
 
   // PnL Hero Card screen