fix: Make fiat enabled transaction types remotely configurable (MetaMask#9050)

## Explanation

This PR makes the set of fiat-eligible transaction types remotely
configurable via feature flags, enabling updates without code releases.

## Changes

### Source changes
- **`constants.ts`**: Added `moneyAccountDeposit` as a fiat-eligible
type (mapped to `ETH_MAINNET_FIAT_ASSET`), removed
`perpsDepositAndOrder`, and added a `FIAT_ENABLED_TYPES` array as the
hardcoded default.
- **`utils.ts`**: Updated `deriveFiatAssetForFiatPayment` and
`resolveTransactionType` to read enabled types from feature flags via
`getFiatEnabledTypes()` instead of using the static
`FIAT_ASSET_ID_BY_TX_TYPE` map. When resolving batch transactions, falls
back to the batch transaction's own type instead of `undefined`.
- **`feature-flags.ts`**: Added `enabledTransactionTypes` to `FiatFlags`
type and added `getFiatEnabledTypes()` function that reads from
`RemoteFeatureFlagController`, falling back to `FIAT_ENABLED_TYPES`.

### Test changes
- Added tests for `getFiatEnabledTypes` covering default fallback,
missing flag, and remote override scenarios.
- Added tests for feature-flag-driven batch transaction type resolution.
- Added test for `getFiatAssetPerTransactionType` with `undefined`
transaction type to maintain 100% coverage.

## References

N/A

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> **Medium Risk**
> Changes which transaction types and batch nested legs qualify for fiat
pay and asset selection; incorrect flag values could enable/disable fiat
flows without a release.
> 
> **Overview**
> Fiat-eligible transaction types can now be driven remotely via
**`confirmations_pay_fiat.enabledTransactionTypes`**, with
**`getFiatEnabledTypes()`** falling back to a new
**`FIAT_ENABLED_TYPES`** default list.
> 
> **Batch fiat asset resolution** no longer keys off “has a fiat asset
mapping”; it picks the first nested child whose type is in the enabled
list, and if none match it keeps the **batch** type (then the usual
asset lookup / ETH mainnet fallback).
> 
> **Default eligibility** shifts: **`moneyAccountDeposit`** is added to
the asset map and enabled defaults; **`perpsDepositAndOrder`** is
removed from the static asset map (still covered only if the remote flag
includes it).
> 
> <sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit
88c7d3e. Bugbot is set up for automated
code reviews on this repo. Configure
[here](https://www.cursor.com/dashboard/bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: OGPoyraz

packages/transaction-pay-controller/CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Changed
+
+- Make fiat-eligible transaction types remotely configurable via `confirmations_pay_fiat.enabledTransactionTypes` feature flag ([#9050](https://github.com/MetaMask/core/pull/9050))
+
 ## [23.5.0]
 
 ### Changed

packages/transaction-pay-controller/src/strategy/fiat/constants.ts

@@ -33,7 +33,13 @@ export const ETH_MAINNET_FIAT_ASSET: TransactionPayFiatAsset = {
 export const FIAT_ASSET_ID_BY_TX_TYPE: Partial<
   Record<TransactionType, TransactionPayFiatAsset>
 > = {
-  [TransactionType.predictDeposit]: POLYGON_POL_FIAT_ASSET,
+  [TransactionType.moneyAccountDeposit]: ETH_MAINNET_FIAT_ASSET,
   [TransactionType.perpsDeposit]: ARBITRUM_ETH_FIAT_ASSET,
-  [TransactionType.perpsDepositAndOrder]: ARBITRUM_ETH_FIAT_ASSET,
+  [TransactionType.predictDeposit]: POLYGON_POL_FIAT_ASSET,
 };
+
+export const FIAT_ENABLED_TYPES: TransactionType[] = [
+  TransactionType.moneyAccountDeposit,
+  TransactionType.perpsDeposit,
+  TransactionType.predictDeposit,
+];

packages/transaction-pay-controller/src/strategy/fiat/utils.test.ts

@@ -197,6 +197,51 @@ describe('Fiat Utils', () => {
 
       expect(result).toStrictEqual(ETH_MAINNET_FIAT_ASSET);
     });
+
+    it('uses feature flag enabled types to filter nested transactions in batch', () => {
+      getRemoteFeatureFlagControllerStateMock.mockReturnValue({
+        ...getDefaultRemoteFeatureFlagControllerState(),
+        remoteFeatureFlags: {
+          confirmations_pay_fiat: {
+            enabledTransactionTypes: [TransactionType.predictDeposit],
+          },
+        },
+      });
+
+      const transaction = {
+        nestedTransactions: [
+          { type: TransactionType.perpsDeposit },
+          { type: TransactionType.predictDeposit },
+        ],
+        type: TransactionType.batch,
+      } as TransactionMeta;
+
+      const result = deriveFiatAssetForFiatPayment(transaction, messenger);
+
+      expect(result).toStrictEqual(
+        FIAT_ASSET_ID_BY_TX_TYPE[TransactionType.predictDeposit],
+      );
+    });
+
+    it('falls back to batch type when no nested transaction matches enabled types', () => {
+      getRemoteFeatureFlagControllerStateMock.mockReturnValue({
+        ...getDefaultRemoteFeatureFlagControllerState(),
+        remoteFeatureFlags: {
+          confirmations_pay_fiat: {
+            enabledTransactionTypes: [TransactionType.predictDeposit],
+          },
+        },
+      });
+
+      const transaction = {
+        nestedTransactions: [{ type: TransactionType.perpsDeposit }],
+        type: TransactionType.batch,
+      } as TransactionMeta;
+
+      const result = deriveFiatAssetForFiatPayment(transaction, messenger);
+
+      expect(result).toStrictEqual(ETH_MAINNET_FIAT_ASSET);
+    });
   });
 
   describe('resolveSourceAmountRaw', () => {

packages/transaction-pay-controller/src/strategy/fiat/utils.ts

@@ -7,34 +7,40 @@ import { BigNumber } from 'bignumber.js';
 
 import { projectLogger } from '../../logger';
 import type { TransactionPayControllerMessenger } from '../../types';
-import { getFiatAssetPerTransactionType } from '../../utils/feature-flags';
+import {
+  getFiatAssetPerTransactionType,
+  getFiatEnabledTypes,
+} from '../../utils/feature-flags';
 import { getTokenInfo } from '../../utils/token';
 import { getTransferredAmountFromTxHash } from '../../utils/transaction';
 import type { RelayQuote } from '../relay/types';
 import type { TransactionPayFiatAsset } from './constants';
-import { FIAT_ASSET_ID_BY_TX_TYPE } from './constants';
 
 const log = createModuleLogger(projectLogger, 'fiat-utils');
 
 export function deriveFiatAssetForFiatPayment(
   transaction: TransactionMeta,
   messenger: TransactionPayControllerMessenger,
 ): TransactionPayFiatAsset {
-  const txType = resolveTransactionType(transaction);
+  const enabledTypes = getFiatEnabledTypes(messenger);
+  const txType = resolveTransactionType(transaction, enabledTypes);
 
   return getFiatAssetPerTransactionType(messenger, txType);
 }
 
 function resolveTransactionType(
   transaction: TransactionMeta,
+  enabledTypes: TransactionType[],
 ): TransactionType | undefined {
   if (transaction.type !== TransactionType.batch) {
     return transaction.type;
   }
 
-  return transaction.nestedTransactions?.find(
-    (tx) => tx.type && FIAT_ASSET_ID_BY_TX_TYPE[tx.type] !== undefined,
+  const nestedType = transaction.nestedTransactions?.find(
+    (tx) => tx.type && enabledTypes.includes(tx.type),
   )?.type;
+
+  return nestedType ?? transaction.type;
 }
 
 /**

packages/transaction-pay-controller/src/utils/feature-flags.test.ts

@@ -4,6 +4,7 @@ import type { Hex } from '@metamask/utils';
 import { getDefaultRemoteFeatureFlagControllerState } from '../../../remote-feature-flag-controller/src/remote-feature-flag-controller';
 import { TransactionPayStrategy } from '../constants';
 import type { TransactionPayFiatAsset } from '../strategy/fiat/constants';
+import { FIAT_ENABLED_TYPES } from '../strategy/fiat/constants';
 import { getMessengerMock } from '../tests/messenger-mock';
 import {
   DEFAULT_ACROSS_API_BASE,
@@ -17,6 +18,7 @@ import {
   getAssetsUnifyStateFeature,
   getFallbackGas,
   getFiatAssetPerTransactionType,
+  getFiatEnabledTypes,
   getFiatFeeReserveMultiplier,
   getFiatMaxRateDriftPercent,
   DEFAULT_RELAY_EXECUTE_URL,
@@ -1423,6 +1425,15 @@ describe('Feature Flags Utils', () => {
       chainId: '0x89',
     };
 
+    it('returns ETH mainnet fallback when transaction type is undefined', () => {
+      const result = getFiatAssetPerTransactionType(messenger, undefined);
+
+      expect(result).toStrictEqual({
+        address: '0x0000000000000000000000000000000000000000',
+        chainId: '0x1',
+      });
+    });
+
     it('returns ETH mainnet fallback when confirmations_pay_fiat flag is absent', () => {
       const result = getFiatAssetPerTransactionType(
         messenger,
@@ -1518,6 +1529,47 @@ describe('Feature Flags Utils', () => {
     });
   });
 
+  describe('getFiatEnabledTypes', () => {
+    it('returns hardcoded defaults when feature flag is absent', () => {
+      const result = getFiatEnabledTypes(messenger);
+
+      expect(result).toStrictEqual(FIAT_ENABLED_TYPES);
+    });
+
+    it('returns hardcoded defaults when confirmations_pay_fiat exists but enabledTransactionTypes is missing', () => {
+      getRemoteFeatureFlagControllerStateMock.mockReturnValue({
+        ...getDefaultRemoteFeatureFlagControllerState(),
+        remoteFeatureFlags: {
+          confirmations_pay_fiat: {},
+        },
+      });
+
+      const result = getFiatEnabledTypes(messenger);
+
+      expect(result).toStrictEqual(FIAT_ENABLED_TYPES);
+    });
+
+    it('returns enabled types from feature flag when set', () => {
+      const customTypes = [
+        TransactionType.perpsDeposit,
+        TransactionType.predictDeposit,
+      ];
+
+      getRemoteFeatureFlagControllerStateMock.mockReturnValue({
+        ...getDefaultRemoteFeatureFlagControllerState(),
+        remoteFeatureFlags: {
+          confirmations_pay_fiat: {
+            enabledTransactionTypes: customTypes,
+          },
+        },
+      });
+
+      const result = getFiatEnabledTypes(messenger);
+
+      expect(result).toStrictEqual(customTypes);
+    });
+  });
+
   describe('getFiatFeeReserveMultiplier', () => {
     it('returns 1.2 when feature flag is not set', () => {
       getRemoteFeatureFlagControllerStateMock.mockReturnValue({

packages/transaction-pay-controller/src/utils/feature-flags.ts

@@ -9,6 +9,7 @@ import type { TransactionPayFiatAsset } from '../strategy/fiat/constants';
 import {
   ETH_MAINNET_FIAT_ASSET,
   FIAT_ASSET_ID_BY_TX_TYPE,
+  FIAT_ENABLED_TYPES,
 } from '../strategy/fiat/constants';
 import {
   RELAY_EXECUTE_URL,
@@ -94,6 +95,7 @@ type FiatFlags = {
   assetPerTransactionType?: Partial<
     Record<TransactionType, TransactionPayFiatAsset>
   >;
+  enabledTransactionTypes: TransactionType[];
   feeReserveMultiplier?: number;
   maxRateDriftPercent?: number;
 };
@@ -826,6 +828,23 @@ export function getFiatAssetPerTransactionType(
   );
 }
 
+/**
+ * Get the enabled fiat transaction types.
+ *
+ * @param messenger - Controller messenger.
+ * @returns The enabled fiat transaction types.
+ */
+export function getFiatEnabledTypes(
+  messenger: TransactionPayControllerMessenger,
+): TransactionType[] {
+  const state = messenger.call('RemoteFeatureFlagController:getState');
+  const fiatFlags = state.remoteFeatureFlags?.confirmations_pay_fiat as
+    | FiatFlags
+    | undefined;
+
+  return fiatFlags?.enabledTransactionTypes ?? FIAT_ENABLED_TYPES;
+}
+
 /**
  * Returns the fee reserve multiplier for fiat three-phase submit.
  *