feat(transaction-pay-controller): add route-based strategy resolution

Author: pedronfigueiredo

packages/transaction-pay-controller/CHANGELOG.md

@@ -10,6 +10,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 
 - Add `FiatStrategy` to retrieve quotes via `RampsController` ([#8121](https://github.com/MetaMask/core/pull/8121))
+- Add route-based `confirmations_pay` strategy resolution via the `getStrategyRouteContext` controller option and `getStrategyOrderForRouteFromFeatureFlags` helper ([#8282](https://github.com/MetaMask/core/pull/8282))
 
 ### Changed
 

packages/transaction-pay-controller/src/TransactionPayController.test.ts

@@ -12,7 +12,11 @@ import type {
   TransactionPayControllerMessenger,
   TransactionPaySourceAmount,
 } from './types';
-import { getStrategyOrder } from './utils/feature-flags';
+import type { TransactionPayRouteContext } from './utils/feature-flags';
+import {
+  getStrategyOrder,
+  getStrategyOrderForRoute,
+} from './utils/feature-flags';
 import { updateQuotes } from './utils/quotes';
 import { updateSourceAmounts } from './utils/source-amounts';
 import { pollTransactionChanges } from './utils/transaction';
@@ -36,6 +40,7 @@ describe('TransactionPayController', () => {
   const updateQuotesMock = jest.mocked(updateQuotes);
   const pollTransactionChangesMock = jest.mocked(pollTransactionChanges);
   const getStrategyOrderMock = jest.mocked(getStrategyOrder);
+  const getStrategyOrderForRouteMock = jest.mocked(getStrategyOrderForRoute);
   let messenger: TransactionPayControllerMessenger;
 
   /**
@@ -55,6 +60,9 @@ describe('TransactionPayController', () => {
 
     messenger = getMessengerMock({ skipRegister: true }).messenger;
     getStrategyOrderMock.mockReturnValue([TransactionPayStrategy.Relay]);
+    getStrategyOrderForRouteMock.mockReturnValue([
+      TransactionPayStrategy.Relay,
+    ]);
     updateQuotesMock.mockResolvedValue(true);
   });
 
@@ -324,6 +332,115 @@ describe('TransactionPayController', () => {
       ).toBe(TransactionPayStrategy.Bridge);
     });
 
+    it('uses route-based feature flag resolution when getStrategyRouteContext is provided', async () => {
+      const getStrategyRouteContext = jest.fn(() => ({
+        chainId: '0xa4b1' as Hex,
+        tokenAddress: '0xabc' as Hex,
+        transactionType: 'perpsDeposit',
+      }));
+
+      getStrategyOrderForRouteMock.mockReturnValue([
+        TransactionPayStrategy.Across,
+      ]);
+
+      new TransactionPayController({
+        getDelegationTransaction: jest.fn(),
+        getStrategyRouteContext,
+        messenger,
+      });
+
+      expect(
+        messenger.call(
+          'TransactionPayController:getStrategy',
+          TRANSACTION_META_MOCK,
+        ),
+      ).toBe(TransactionPayStrategy.Across);
+      expect(getStrategyRouteContext).toHaveBeenCalledWith(
+        TRANSACTION_META_MOCK,
+      );
+      expect(getStrategyOrderForRouteMock).toHaveBeenCalledWith(messenger, {
+        chainId: '0xa4b1',
+        tokenAddress: '0xabc',
+        transactionType: 'perpsDeposit',
+      });
+    });
+
+    it('falls back to default strategy order when route-based resolution returns no strategies', async () => {
+      getStrategyOrderForRouteMock.mockReturnValue([]);
+      getStrategyOrderMock.mockReturnValue([TransactionPayStrategy.Relay]);
+
+      new TransactionPayController({
+        getDelegationTransaction: jest.fn(),
+        getStrategyRouteContext: (): TransactionPayRouteContext => ({
+          chainId: '0xa4b1' as Hex,
+          tokenAddress: '0xabc' as Hex,
+          transactionType: 'perpsDeposit',
+        }),
+        messenger,
+      });
+
+      expect(
+        messenger.call(
+          'TransactionPayController:getStrategy',
+          TRANSACTION_META_MOCK,
+        ),
+      ).toBe(TransactionPayStrategy.Relay);
+      expect(getStrategyOrderForRouteMock).toHaveBeenCalledWith(messenger, {
+        chainId: '0xa4b1',
+        tokenAddress: '0xabc',
+        transactionType: 'perpsDeposit',
+      });
+      expect(getStrategyOrderMock).toHaveBeenCalledWith(messenger);
+    });
+
+    it('falls back to default strategy order for quote refresh when route-based resolution returns no strategies', async () => {
+      getStrategyOrderForRouteMock.mockReturnValue([]);
+      getStrategyOrderMock.mockReturnValue([TransactionPayStrategy.Relay]);
+
+      const controller = new TransactionPayController({
+        getDelegationTransaction: jest.fn(),
+        getStrategyRouteContext: (): TransactionPayRouteContext => ({
+          chainId: '0xa4b1' as Hex,
+          tokenAddress: '0xabc' as Hex,
+          transactionType: 'perpsDeposit',
+        }),
+        messenger,
+      });
+
+      controller.setTransactionConfig(TRANSACTION_ID_MOCK, (config) => {
+        config.isPostQuote = true;
+      });
+
+      const { getStrategies } = updateQuotesMock.mock.calls[0][0];
+
+      expect(getStrategies(TRANSACTION_META_MOCK)).toStrictEqual([
+        TransactionPayStrategy.Relay,
+      ]);
+    });
+
+    it('prefers explicit getStrategies values over route-based feature flag resolution', async () => {
+      new TransactionPayController({
+        getDelegationTransaction: jest.fn(),
+        getStrategies: (): TransactionPayStrategy[] => [
+          TransactionPayStrategy.Test,
+        ],
+        getStrategyRouteContext: (): TransactionPayRouteContext => ({
+          chainId: '0xa4b1' as Hex,
+          tokenAddress: '0xabc' as Hex,
+          transactionType: 'perpsDeposit',
+        }),
+        messenger,
+      });
+
+      expect(
+        messenger.call(
+          'TransactionPayController:getStrategy',
+          TRANSACTION_META_MOCK,
+        ),
+      ).toBe(TransactionPayStrategy.Test);
+      expect(getStrategyOrderForRouteMock).not.toHaveBeenCalled();
+    });
+
     it('returns default strategy order when no callbacks and no strategy order feature flag', async () => {
       getStrategyOrderMock.mockReturnValue([TransactionPayStrategy.Relay]);
 

packages/transaction-pay-controller/src/TransactionPayController.ts

@@ -22,7 +22,11 @@ import type {
   UpdateFiatPaymentRequest,
   UpdatePaymentTokenRequest,
 } from './types';
-import { getStrategyOrder } from './utils/feature-flags';
+import {
+  getStrategyOrder,
+  getStrategyOrderForRoute,
+} from './utils/feature-flags';
+import type { TransactionPayRouteContext } from './utils/feature-flags';
 import { updateQuotes } from './utils/quotes';
 import { updateSourceAmounts } from './utils/source-amounts';
 import { pollTransactionChanges } from './utils/transaction';
@@ -63,10 +67,15 @@ export class TransactionPayController extends BaseController<
     transaction: TransactionMeta,
   ) => TransactionPayStrategy[];
 
+  readonly #getStrategyRouteContext?: (
+    transaction: TransactionMeta,
+  ) => TransactionPayRouteContext;
+
   constructor({
     getDelegationTransaction,
     getStrategy,
     getStrategies,
+    getStrategyRouteContext,
     messenger,
     state,
   }: TransactionPayControllerOptions) {
@@ -80,6 +89,7 @@ export class TransactionPayController extends BaseController<
     this.#getDelegationTransaction = getDelegationTransaction;
     this.#getStrategy = getStrategy;
     this.#getStrategies = getStrategies;
+    this.#getStrategyRouteContext = getStrategyRouteContext;
 
     this.messenger.registerMethodActionHandlers(
       this,
@@ -270,8 +280,21 @@ export class TransactionPayController extends BaseController<
         isTransactionPayStrategy(strategy),
     );
 
-    return validStrategies.length
-      ? validStrategies
-      : getStrategyOrder(this.messenger);
+    if (validStrategies.length) {
+      return validStrategies;
+    }
+
+    if (this.#getStrategyRouteContext) {
+      const routeStrategies = getStrategyOrderForRoute(
+        this.messenger,
+        this.#getStrategyRouteContext(transaction),
+      );
+
+      if (routeStrategies.length) {
+        return routeStrategies;
+      }
+    }
+
+    return getStrategyOrder(this.messenger);
   }
 }

packages/transaction-pay-controller/src/index.ts

@@ -29,3 +29,5 @@ export { TransactionPayStrategy } from './constants';
 export { TransactionPayController } from './TransactionPayController';
 export { TransactionPayPublishHook } from './helpers/TransactionPayPublishHook';
 export type { TransactionPayBridgeQuote } from './strategy/bridge/types';
+export type { TransactionPayRouteContext } from './utils/feature-flags';
+export { getStrategyOrderForRouteFromFeatureFlags } from './utils/feature-flags';

packages/transaction-pay-controller/src/types.ts

@@ -38,6 +38,7 @@ import type { Draft } from 'immer';
 
 import type { CONTROLLER_NAME, TransactionPayStrategy } from './constants';
 import type { TransactionPayControllerMethodActions } from './TransactionPayController-method-action-types';
+import type { TransactionPayRouteContext } from './utils/feature-flags';
 
 export type AllowedActions =
   | AccountTrackerControllerGetStateAction
@@ -131,6 +132,14 @@ export type TransactionPayControllerOptions = {
   /** Callback to select ordered PayStrategies for a transaction. */
   getStrategies?: (transaction: TransactionMeta) => TransactionPayStrategy[];
 
+  /**
+   * Callback to derive route context for generic feature-flag based strategy selection.
+   * Used when no custom strategy callback returns a valid ordered strategy list.
+   */
+  getStrategyRouteContext?: (
+    transaction: TransactionMeta,
+  ) => TransactionPayRouteContext;
+
   /** Controller messenger. */
   messenger: TransactionPayControllerMessenger;