fix(transaction-pay): allow perps withdraw to Arbitrum USDC by skipping same-token filter for HyperLiquid source (#8387)

## Explanation

When a user initiates a perps withdrawal targeting Arbitrum USDC, the
`calculatePostQuoteSourceAmounts` function filters out the source token
because it matches the destination token (both are Arbitrum USDC on
chain `0xa4b1`). This prevents any Relay quote requests from being
built, so `calculateTotals` falls back to computing raw gas cost on the
dummy Arbitrum transaction — producing an absurd ~$16M transaction fee.

The relay strategy's `normalizeRequest()` would have renormalized the
source from Arbitrum USDC to HyperCore USDC (chain `0x539`, 8 decimals),
making them distinct tokens. But this normalization happens downstream
of the source-amounts filter, so it never gets a chance to run.

Withdrawing to a different token (e.g. BNB) works fine because
`isSameToken` returns false, so the filter doesn't apply and the Relay
quote is fetched normally.

Fixes https://consensyssoftware.atlassian.net/browse/CONF-1150

## Changes

- Pass `isHyperliquidSource` from `transactionData` into
`calculatePostQuoteSourceAmounts`
- Bypass the `isSameToken` filter when `isHyperliquidSource` is true,
since the relay strategy will renormalize the source to HyperCore USDC
(a different chain)
- Add unit tests for the new behavior and confirm existing behavior is
preserved

## References

- Affected flow: Perps → Withdraw → Receive USDC (Arbitrum)
- Root cause: `isSameToken(ArbitrumUSDC, ArbitrumUSDC)` → `true` →
source amount filtered out → no quotes → fallback to raw transaction gas
cost

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> **Medium Risk**
> Adjusts post-quote source-amount filtering logic for
`isHyperliquidSource`, which affects whether Relay quotes are requested
and therefore impacts fee/quote calculation for withdrawals. Scoped
behind a specific flag, but regressions could alter quoting behavior for
post-quote flows.
> 
> **Overview**
> Fixes HyperLiquid *post-quote (withdrawal)* flows where the source
token could be incorrectly dropped as “same as destination,” preventing
Relay quote requests and leading to wildly incorrect fee estimates.
> 
> `updateSourceAmounts` now passes `transactionData.isHyperliquidSource`
into `calculatePostQuoteSourceAmounts`, which bypasses the
same-token/same-chain filter when that flag is true. Adds unit tests
covering the new HyperLiquid behavior and preserving the existing
same-token filtering when the flag is false, and records the fix in the
changelog.
> 
> <sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit
fbcb2ee. Bugbot is set up for automated
code reviews on this repo. Configure
[here](https://www.cursor.com/dashboard/bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

---------

Signed-off-by: dan437 <80175477+dan437@users.noreply.github.com>

Author: dan437

packages/transaction-pay-controller/CHANGELOG.md

@@ -11,6 +11,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Support for perps deposit for Across ([#8334](https://github.com/MetaMask/core/pull/8334))
 
+### Fixed
+
+- Fix perps withdraw to Arbitrum USDC showing inflated transaction fee by bypassing same-token filter when `isHyperliquidSource` is set ([#8387](https://github.com/MetaMask/core/pull/8387))
+
 ## [19.0.3]
 
 ### Changed

packages/transaction-pay-controller/src/utils/source-amounts.test.ts

@@ -353,6 +353,63 @@ describe('Source Amounts Utils', () => {
         expect(transactionData.sourceAmounts).toStrictEqual([]);
       });
 
+      it('does not filter out same token when isHyperliquidSource is true in post-quote flow', () => {
+        const transactionData: TransactionData = {
+          isLoading: false,
+          isPostQuote: true,
+          isHyperliquidSource: true,
+          paymentToken: {
+            ...DESTINATION_TOKEN_MOCK,
+            address: ARBITRUM_USDC_ADDRESS,
+            chainId: CHAIN_ID_ARBITRUM,
+            decimals: 6,
+            symbol: 'USDC',
+          },
+          tokens: [
+            {
+              ...TRANSACTION_TOKEN_MOCK,
+              address: ARBITRUM_USDC_ADDRESS,
+              chainId: CHAIN_ID_ARBITRUM,
+              skipIfBalance: false,
+            },
+          ],
+        };
+
+        updateSourceAmounts(TRANSACTION_ID_MOCK, transactionData, messenger);
+
+        expect(transactionData.sourceAmounts).toStrictEqual([
+          {
+            sourceAmountHuman: TRANSACTION_TOKEN_MOCK.amountHuman,
+            sourceAmountRaw: TRANSACTION_TOKEN_MOCK.amountRaw,
+            sourceBalanceRaw: TRANSACTION_TOKEN_MOCK.balanceRaw,
+            sourceChainId: CHAIN_ID_ARBITRUM,
+            sourceTokenAddress: ARBITRUM_USDC_ADDRESS,
+            targetTokenAddress: ARBITRUM_USDC_ADDRESS,
+          },
+        ]);
+      });
+
+      it('still filters out same token when isHyperliquidSource is false in post-quote flow', () => {
+        const transactionData: TransactionData = {
+          isLoading: false,
+          isPostQuote: true,
+          isHyperliquidSource: false,
+          paymentToken: DESTINATION_TOKEN_MOCK,
+          tokens: [
+            {
+              ...TRANSACTION_TOKEN_MOCK,
+              address: DESTINATION_TOKEN_MOCK.address,
+              chainId: DESTINATION_TOKEN_MOCK.chainId,
+              skipIfBalance: false,
+            },
+          ],
+        };
+
+        updateSourceAmounts(TRANSACTION_ID_MOCK, transactionData, messenger);
+
+        expect(transactionData.sourceAmounts).toStrictEqual([]);
+      });
+
       it('uses token balance when isMaxAmount is true in post-quote flow', () => {
         const transactionData: TransactionData = {
           isLoading: false,

packages/transaction-pay-controller/src/utils/source-amounts.ts

@@ -45,10 +45,12 @@ export function updateSourceAmounts(
   // For post-quote flows, source amounts are calculated differently
   // The source is the transaction's required token, not the selected token
   if (isPostQuote) {
+    const { isHyperliquidSource } = transactionData;
     const sourceAmounts = calculatePostQuoteSourceAmounts(
       tokens,
       paymentToken,
       isMaxAmount ?? false,
+      isHyperliquidSource,
     );
     log('Updated post-quote source amounts', { transactionId, sourceAmounts });
     transactionData.sourceAmounts = sourceAmounts;
@@ -80,12 +82,14 @@ export function updateSourceAmounts(
  * @param tokens - Required tokens from the transaction.
  * @param paymentToken - Selected payment/destination token.
  * @param isMaxAmount - Whether the transaction is a maximum amount transaction.
+ * @param isHyperliquidSource - Whether the source is HyperLiquid (perps withdrawal).
  * @returns Array of source amounts.
  */
 function calculatePostQuoteSourceAmounts(
   tokens: TransactionPayRequiredToken[],
   paymentToken: TransactionPaymentToken,
   isMaxAmount: boolean,
+  isHyperliquidSource?: boolean,
 ): TransactionPaySourceAmount[] {
   return tokens
     .filter((token) => {
@@ -99,8 +103,11 @@ function calculatePostQuoteSourceAmounts(
         return false;
       }
 
-      // Skip same token on same chain
-      if (isSameToken(token, paymentToken)) {
+      // Skip same token on same chain, unless the source is HyperLiquid.
+      // For HyperLiquid withdrawals the relay strategy renormalizes the
+      // source from Arbitrum USDC to HyperCore USDC (a different chain),
+      // so the tokens are not actually the same after normalization.
+      if (isSameToken(token, paymentToken) && !isHyperliquidSource) {
         log('Skipping token as same as destination token');
         return false;
       }