feat: cp-7.78.0 support deposit-wallet polymarket withdraw (#29953)

Adopts the new Polymarket deposit-wallet support landed in
[@metamask/transaction-pay-controller@22.5.0](MetaMask/core#8754)
so Polymarket users whose pUSD lives in a deposit wallet (a per-user
batch contract on Polygon) can withdraw cross-chain through MetaMask
Pay.

Highlights:

- Lets Polymarket deposit-wallet users withdraw cross-chain through
MetaMask Pay.
- Gated behind a new remote feature flag, with the existing "withdraw
unavailable" sheet preserved when off.
- Polishes Predict withdraw activity rendering.

CHANGELOG entry: null

<!-- Internal -->

```gherkin
Feature: Polymarket deposit-wallet withdraw

  Scenario: deposit-wallet user with the flag on
    Given enableDepositWalletWithdraw is on
    And the user has a Polymarket deposit wallet with pUSD balance on Polygon
    When the user taps Withdraw on the Predict balance
    Then the standard Pay confirmation opens
    And confirming submits via the Polymarket strategy with no Polygon gas

  Scenario: deposit-wallet user with the flag off
    Given enableDepositWalletWithdraw is off
    When the user taps Withdraw on the Predict balance
    Then the existing "Withdraw unavailable" sheet is shown
```

<img width="300" alt="Activity"
src="https://github.com/user-attachments/assets/13d5a0e9-a39d-4c0a-9fde-468c5a0a7743"
/>

- [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.

- [ ] I've tested on Android
- [ ] I've tested with a power user scenario
- [ ] I've instrumented key operations with Sentry traces for production
performance metrics

- [ ] 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 withdrawal behavior and MetaMask Pay transaction configuration
for Polymarket `predictWithdraw`, including new controller callbacks and
retry logic; mistakes could impact withdraw routing/fees for affected
users. Gated by a remote feature flag, limiting blast radius.
>
> **Overview**
> Enables Polymarket *deposit-wallet* users to run `predictWithdraw`
through MetaMask Pay when the new
`confirmations_pay_extended.enableDepositWalletWithdraw` flag is on;
when off, the existing “withdraw unavailable” handling remains.
>
> Updates Predict/Pay plumbing for deposit-wallet withdraws:
`PredictController.prepareWithdraw` now omits `gasFeeToken` for
deposit-wallet accounts, `useTransactionPayPostQuote` skips `refundTo`
and marks `isPolymarketDepositWallet`, and Transaction Pay
initialization wires new Polymarket callbacks that can derive
deposit-wallet addresses and submit deposit-wallet batches (with “wallet
busy” retries + keyring signing support).
>
> Polishes confirmations activity rendering for `predictWithdraw` by
adding a dedicated `predict_withdraw` title and treating it as a
receive-summary type using the source token/network metadata. Tests are
added/updated accordingly, and `@metamask/transaction-pay-controller` is
bumped to `22.5.0`.
>
> <sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit
054697c. Bugbot is set up for automated
code reviews on this repo. Configure
[here](https://www.cursor.com/dashboard/bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: matthewwalsh0

app/components/UI/Predict/components/PredictBalance/PredictBalance.test.tsx

@@ -76,6 +76,25 @@ const initialState = {
   },
 };
 
+function stateWithDepositWalletWithdrawEnabled(enabled: boolean) {
+  return {
+    engine: {
+      backgroundState: {
+        ...initialState.engine.backgroundState,
+        RemoteFeatureFlagController: {
+          ...backgroundState.RemoteFeatureFlagController,
+          remoteFeatureFlags: {
+            ...backgroundState.RemoteFeatureFlagController?.remoteFeatureFlags,
+            confirmations_pay_extended: {
+              enableDepositWalletWithdraw: enabled,
+            },
+          },
+        },
+      },
+    },
+  };
+}
+
 describe('PredictBalance', () => {
   beforeEach(() => {
     jest.clearAllMocks();
@@ -387,6 +406,43 @@ describe('PredictBalance', () => {
       expect(mockExecuteGuardedAction).not.toHaveBeenCalled();
     });
 
+    it('calls withdraw for Deposit Wallet users when enableDepositWalletWithdraw flag is on', () => {
+      // Arrange
+      const mockWithdraw = jest.fn();
+      const mockOnDepositWalletWithdrawPress = jest.fn();
+      mockUsePredictBalance.mockReturnValue({
+        data: 100,
+        isLoading: false,
+      });
+      mockUsePredictAccountState.mockReturnValue({
+        data: {
+          address: '0x2222222222222222222222222222222222222222',
+          isDeployed: true,
+          walletType: 'deposit-wallet',
+        },
+        isLoading: false,
+      });
+      mockUsePredictWithdraw.mockReturnValue({
+        withdraw: mockWithdraw,
+      });
+
+      // Act
+      const { getByText } = renderWithProvider(
+        <PredictBalance
+          onDepositWalletWithdrawPress={mockOnDepositWalletWithdrawPress}
+        />,
+        {
+          state: stateWithDepositWalletWithdrawEnabled(true),
+        },
+      );
+      const withdrawButton = getByText(/Withdraw/i);
+      fireEvent.press(withdrawButton);
+
+      // Assert
+      expect(mockWithdraw).toHaveBeenCalledTimes(1);
+      expect(mockOnDepositWalletWithdrawPress).not.toHaveBeenCalled();
+    });
+
     it('calls temporary unavailable handler instead of withdrawing for Deposit Wallet users', () => {
       // Arrange
       const mockWithdraw = jest.fn();

app/components/UI/Predict/components/PredictBalance/PredictBalance.tsx

@@ -41,6 +41,7 @@ import { PredictNavigationParamList } from '../../types/navigation';
 import { usePredictWithdraw } from '../../hooks/usePredictWithdraw';
 import { usePredictAccountState } from '../../hooks/usePredictAccountState';
 import { PredictEventValues } from '../../constants/eventNames';
+import { selectMetaMaskPayFlags } from '../../../../../selectors/featureFlagController/confirmations';
 import { PREDICT_BALANCE_TEST_IDS } from './PredictBalance.testIds';
 
 // This is a temporary component that will be removed when the deposit flow is fully implemented
@@ -55,6 +56,7 @@ const PredictBalance: React.FC<PredictBalanceProps> = ({
 }) => {
   const tw = useTailwind();
   const privacyMode = useSelector(selectPrivacyMode);
+  const { enableDepositWalletWithdraw } = useSelector(selectMetaMaskPayFlags);
 
   const navigation =
     useNavigation<NavigationProp<PredictNavigationParamList>>();
@@ -103,15 +105,18 @@ const PredictBalance: React.FC<PredictBalanceProps> = ({
       return;
     }
 
-    // Temporary Deposit Wallet migration guard. Remove this branch and sheet
-    // once Deposit Wallet withdrawals are implemented.
-    if (walletType === 'deposit-wallet') {
+    if (walletType === 'deposit-wallet' && !enableDepositWalletWithdraw) {
       onDepositWalletWithdrawPress?.();
       return;
     }
 
     withdraw();
-  }, [onDepositWalletWithdrawPress, walletType, withdraw]);
+  }, [
+    enableDepositWalletWithdraw,
+    onDepositWalletWithdrawPress,
+    walletType,
+    withdraw,
+  ]);
 
   if (isLoading) {
     return (

app/components/UI/Predict/controllers/PredictController.test.ts

@@ -288,6 +288,11 @@ describe('PredictController', () => {
       syncDepositWalletBalanceAllowanceForDepositTransaction: jest.fn(),
     } as unknown as jest.Mocked<PolymarketProvider>;
 
+    mockPolymarketProvider.getAccountState.mockResolvedValue({
+      address: '0xProxyAddress' as `0x${string}`,
+      isDeployed: true,
+      walletType: 'safe' as const,
+    });
     mockPolymarketProvider.beforePublishDepositWalletDeposit.mockResolvedValue(
       true,
     );
@@ -6076,6 +6081,54 @@ describe('PredictController', () => {
       });
     });
 
+    it('sets gasFeeToken when account walletType is not deposit-wallet', async () => {
+      mockPolymarketProvider.prepareWithdraw.mockResolvedValue(
+        mockWithdrawResponse,
+      );
+      mockPolymarketProvider.getAccountState.mockResolvedValue({
+        address: '0xProxyAddress' as `0x${string}`,
+        isDeployed: true,
+        walletType: 'safe' as const,
+      });
+      (addTransactionBatch as jest.Mock).mockResolvedValue({
+        batchId: 'batch-safe',
+      });
+
+      await withController(async ({ controller }) => {
+        await controller.prepareWithdraw({});
+
+        expect(addTransactionBatch).toHaveBeenCalledWith(
+          expect.objectContaining({
+            gasFeeToken: MATIC_CONTRACTS_V2.collateral,
+          }),
+        );
+      });
+    });
+
+    it('omits gasFeeToken when account walletType is deposit-wallet', async () => {
+      mockPolymarketProvider.prepareWithdraw.mockResolvedValue(
+        mockWithdrawResponse,
+      );
+      mockPolymarketProvider.getAccountState.mockResolvedValue({
+        address: '0xDepositWalletAddress' as `0x${string}`,
+        isDeployed: true,
+        walletType: 'deposit-wallet' as const,
+      });
+      (addTransactionBatch as jest.Mock).mockResolvedValue({
+        batchId: 'batch-deposit',
+      });
+
+      await withController(async ({ controller }) => {
+        await controller.prepareWithdraw({});
+
+        expect(addTransactionBatch).toHaveBeenCalledWith(
+          expect.objectContaining({
+            gasFeeToken: undefined,
+          }),
+        );
+      });
+    });
+
     it('update transaction ID when batch ID is returned', async () => {
       const mockBatchId = 'tx-batch-update';
 

app/components/UI/Predict/controllers/PredictController.ts

@@ -2595,6 +2595,16 @@ export class PredictController extends BaseController<
           signer,
         });
 
+      const accountState = await provider.getAccountState({
+        ownerAddress: signer.address,
+      });
+
+      const isDepositWallet = accountState.walletType === 'deposit-wallet';
+
+      const gasFeeToken = isDepositWallet
+        ? undefined
+        : (MATIC_CONTRACTS_V2.collateral as Hex);
+
       this.update((state) => {
         state.withdrawTransaction = {
           chainId: hexToNumber(chainId),
@@ -2616,9 +2626,8 @@ export class PredictController extends BaseController<
         disableHook: true,
         disableSequential: true,
         requireApproval: true,
-        // Temporarily breaking abstraction, can instead be abstracted via provider.
-        gasFeeToken: MATIC_CONTRACTS_V2.collateral as Hex,
         transactions: [transaction],
+        gasFeeToken,
       });
 
       this.update((state) => {

app/components/Views/confirmations/components/activity/transaction-details-summary/receive-summary-line.test.tsx

@@ -13,6 +13,7 @@ import { selectBridgeHistoryForAccount } from '../../../../../../selectors/bridg
 import { useBridgeTxHistoryData } from '../../../../../../util/bridge/hooks/useBridgeTxHistoryData';
 import { useTokenAmount } from '../../../hooks/useTokenAmount';
 import { useTransactionDetails } from '../../../hooks/activity/useTransactionDetails';
+import { useTokenWithBalance } from '../../../hooks/tokens/useTokenWithBalance';
 import { ReceiveSummaryLine } from './receive-summary-line';
 
 jest.mock('../../../../../UI/Bridge/hooks/useMultichainBlockExplorerTxUrl');
@@ -21,6 +22,7 @@ jest.mock('../../../../../../selectors/bridgeStatusController');
 jest.mock('../../../../../../util/bridge/hooks/useBridgeTxHistoryData');
 jest.mock('../../../hooks/useTokenAmount');
 jest.mock('../../../hooks/activity/useTransactionDetails');
+jest.mock('../../../hooks/tokens/useTokenWithBalance');
 
 jest.mock('@react-navigation/native', () => ({
   ...jest.requireActual('@react-navigation/native'),
@@ -161,4 +163,36 @@ describe('ReceiveSummaryLine', () => {
       ),
     ).toBeDefined();
   });
+
+  it('renders predict withdraw title using source token symbol and source network', () => {
+    useNetworkNameMock.mockImplementation((chainId?: Hex) =>
+      chainId === '0x1' ? 'Ethereum' : 'Polygon',
+    );
+    jest
+      .mocked(useTokenWithBalance)
+      .mockReturnValue({ symbol: 'USDC' } as ReturnType<
+        typeof useTokenWithBalance
+      >);
+
+    const { getByText } = render({
+      id: 'tx-id',
+      chainId: '0x89' as Hex,
+      hash: '0x123',
+      submittedTime: 1755719285723,
+      type: TransactionType.predictWithdraw,
+      metamaskPay: {
+        chainId: '0x1' as Hex,
+        tokenAddress: '0xabc' as Hex,
+      },
+    } as Partial<TransactionMeta>);
+
+    expect(
+      getByText(
+        strings('transaction_details.summary_title.bridge_receive', {
+          targetSymbol: 'USDC',
+          targetChain: 'Ethereum',
+        }),
+      ),
+    ).toBeDefined();
+  });
 });

app/components/Views/confirmations/components/activity/transaction-details-summary/receive-summary-line.tsx

@@ -10,6 +10,7 @@ import { hasTransactionType } from '../../../utils/transaction';
 import { useNetworkName } from '../../../hooks/useNetworkName';
 import { POLYGON_PUSD } from '../../../constants/predict';
 import { TransactionSummaryLine } from './transaction-summary-line';
+import { useTokenWithBalance } from '../../../hooks/tokens/useTokenWithBalance';
 
 const HYPERLIQUID_EXPLORER_URL = 'https://app.hyperliquid.xyz/explorer/tx';
 const HYPERLIQUID_EXPLORER_NAME = 'Hyperliquid';
@@ -19,7 +20,10 @@ export function ReceiveSummaryLine({
 }: {
   transactionMeta: TransactionMeta;
 }) {
-  const { chainId } = transactionMeta;
+  const { chainId: targetChainId, metamaskPay } = transactionMeta;
+  const sourceChainId = metamaskPay?.chainId;
+  const sourceTokenAddress = metamaskPay?.tokenAddress;
+
   const isPerpsDeposit = hasTransactionType(transactionMeta, [
     TransactionType.perpsDeposit,
   ]);
@@ -28,25 +32,39 @@ export function ReceiveSummaryLine({
     TransactionType.predictDeposit,
   ]);
 
-  const networkName = useNetworkName(chainId);
+  const isPredictWithdraw = hasTransactionType(transactionMeta, [
+    TransactionType.predictWithdraw,
+  ]);
+
+  const targetNetworkName = useNetworkName(targetChainId);
+  const sourceNetworkName = useNetworkName(sourceChainId ?? '0x0');
+
+  const sourceToken = useTokenWithBalance(
+    sourceTokenAddress ?? '0x0',
+    sourceChainId ?? '0x0',
+  );
 
   let targetSymbol = 'mUSD';
-  let targetNetworkName: string | undefined = networkName;
-  let receiveChainId: Hex = chainId;
+  let finalTargetNetworkName: string | undefined = targetNetworkName;
+  let receiveChainId: Hex = targetChainId;
 
   if (isPerpsDeposit) {
     targetSymbol = 'USDC';
-    targetNetworkName = 'Hyperliquid';
+    finalTargetNetworkName = 'Hyperliquid';
     receiveChainId = CHAIN_IDS.ARBITRUM;
   } else if (isPredictDeposit) {
     targetSymbol = POLYGON_PUSD.symbol;
+  } else if (isPredictWithdraw) {
+    targetSymbol = sourceToken?.symbol ?? 'Unknown';
+    finalTargetNetworkName = sourceNetworkName;
+    receiveChainId = sourceChainId ?? '0x0';
   }
 
   const title =
-    targetSymbol && targetNetworkName
+    targetSymbol && finalTargetNetworkName
       ? strings('transaction_details.summary_title.bridge_receive', {
           targetSymbol,
-          targetChain: targetNetworkName,
+          targetChain: finalTargetNetworkName,
         })
       : strings('transaction_details.summary_title.bridge_receive_loading');
 

app/components/Views/confirmations/components/activity/transaction-details-summary/source-hash-summary-line.test.tsx

@@ -1,6 +1,9 @@
 import React from 'react';
 import { fireEvent } from '@testing-library/react-native';
-import { TransactionMeta } from '@metamask/transaction-controller';
+import {
+  TransactionMeta,
+  TransactionType,
+} from '@metamask/transaction-controller';
 import { Hex } from '@metamask/utils';
 import renderWithProvider from '../../../../../../util/test/renderWithProvider';
 import { strings } from '../../../../../../../locales/i18n';
@@ -31,19 +34,19 @@ jest.mock('@react-navigation/native', () => ({
   }),
 }));
 
-function render() {
+function render(parentTransaction?: Partial<TransactionMeta>) {
   return renderWithProvider(
     <SourceHashSummaryLine
       parentTransaction={
-        {
+        (parentTransaction ?? {
           id: 'parent-id',
           chainId: '0x1',
           submittedTime: 1755719285723,
           metamaskPay: {
             tokenAddress: '0x123',
             chainId: '0x1',
           },
-        } as unknown as TransactionMeta
+        }) as unknown as TransactionMeta
       }
       sourceHash={'0xabc' as Hex}
     />,
@@ -118,4 +121,30 @@ describe('SourceHashSummaryLine', () => {
       },
     });
   });
+
+  it('renders predict-withdraw title with pUSD and target network', () => {
+    useNetworkNameMock.mockImplementation((chainId?: Hex) =>
+      chainId === '0x89' ? 'Polygon' : 'Ethereum',
+    );
+
+    const { getByText } = render({
+      id: 'parent-id',
+      chainId: '0x89' as Hex,
+      submittedTime: 1755719285723,
+      type: TransactionType.predictWithdraw,
+      metamaskPay: {
+        tokenAddress: '0x123' as Hex,
+        chainId: '0x1' as Hex,
+      },
+    } as Partial<TransactionMeta>);
+
+    expect(
+      getByText(
+        strings('transaction_details.summary_title.predict_withdraw', {
+          sourceSymbol: 'pUSD',
+          sourceChain: 'Polygon',
+        }),
+      ),
+    ).toBeDefined();
+  });
 });