feat(transaction-pay): add Across strategy support

packages/transaction-controller/CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- Add `perpsAcrossDeposit` and `predictAcrossDeposit` transaction types for Across MetaMask Pay submissions ([#7886](https://github.com/MetaMask/core/pull/7886))
+
 ## [62.18.0]
 
 ### Added

packages/transaction-controller/src/types.ts

@@ -785,6 +785,11 @@ export enum TransactionType {
    */
   musdConversion = 'musdConversion',
 
+  /**
+   * Deposit funds for Across quote via Perps.
+   */
+  perpsAcrossDeposit = 'perpsAcrossDeposit',
+
   /**
    * Deposit funds to be available for trading via Perps.
    */
@@ -806,6 +811,11 @@ export enum TransactionType {
    */
   personalSign = 'personal_sign',
 
+  /**
+   * Deposit funds for Across quote via Predict.
+   */
+  predictAcrossDeposit = 'predictAcrossDeposit',
+
   /**
    * Buy a position via Predict.
    *

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 ordered strategy fallback mechanism for quote retrieval ([#7868](https://github.com/MetaMask/core/pull/7868))
+- Add Across pay strategy support, including Across quote retrieval/normalization and Across submission flow with approval + deposit execution paths ([#7886](https://github.com/MetaMask/core/pull/7886))
 
 ## [16.0.0]
 

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

@@ -33,6 +33,7 @@ export const STABLECOINS: Record<Hex, Hex[]> = {
 };
 
 export enum TransactionPayStrategy {
+  Across = 'across',
   Bridge = 'bridge',
   Relay = 'relay',
   Test = 'test',

packages/transaction-pay-controller/src/strategy/across/AcrossStrategy.test.ts

@@ -0,0 +1,188 @@
+import type { TransactionMeta } from '@metamask/transaction-controller';
+import {
+  TransactionStatus,
+  TransactionType,
+} from '@metamask/transaction-controller';
+import type { Hex } from '@metamask/utils';
+
+import { getAcrossQuotes } from './across-quotes';
+import { submitAcrossQuotes } from './across-submit';
+import { AcrossStrategy } from './AcrossStrategy';
+import type { AcrossQuote } from './types';
+import type {
+  PayStrategyExecuteRequest,
+  PayStrategyGetQuotesRequest,
+  TransactionPayQuote,
+} from '../../types';
+import { getPayStrategiesConfig } from '../../utils/feature-flags';
+
+jest.mock('./across-quotes');
+jest.mock('./across-submit');
+jest.mock('../../utils/feature-flags');
+
+describe('AcrossStrategy', () => {
+  const getPayStrategiesConfigMock = jest.mocked(getPayStrategiesConfig);
+  const getAcrossQuotesMock = jest.mocked(getAcrossQuotes);
+  const submitAcrossQuotesMock = jest.mocked(submitAcrossQuotes);
+
+  const messenger = {} as never;
+
+  const TRANSACTION_META_MOCK = {
+    id: 'tx-1',
+    chainId: '0x1',
+    networkClientId: 'mainnet',
+    status: TransactionStatus.unapproved,
+    time: Date.now(),
+    txParams: {
+      from: '0xabc',
+    },
+  } as TransactionMeta;
+
+  const baseRequest = {
+    messenger,
+    transaction: TRANSACTION_META_MOCK,
+    requests: [
+      {
+        from: '0xabc' as Hex,
+        sourceBalanceRaw: '100',
+        sourceChainId: '0x1' as Hex,
+        sourceTokenAddress: '0xabc' as Hex,
+        sourceTokenAmount: '100',
+        targetAmountMinimum: '100',
+        targetChainId: '0x2' as Hex,
+        targetTokenAddress: '0xdef' as Hex,
+      },
+    ],
+  } as PayStrategyGetQuotesRequest;
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    getPayStrategiesConfigMock.mockReturnValue({
+      across: {
+        allowSameChain: false,
+        apiBase: 'https://across.test',
+        enabled: true,
+      },
+      relay: {
+        enabled: true,
+      },
+    });
+  });
+
+  it('returns false when across is disabled', () => {
+    getPayStrategiesConfigMock.mockReturnValue({
+      across: {
+        allowSameChain: false,
+        apiBase: 'https://across.test',
+        enabled: false,
+      },
+      relay: {
+        enabled: true,
+      },
+    });
+
+    const strategy = new AcrossStrategy();
+    expect(strategy.supports(baseRequest)).toBe(false);
+  });
+
+  it('returns true for perps deposits when other constraints are met', () => {
+    const strategy = new AcrossStrategy();
+    expect(
+      strategy.supports({
+        ...baseRequest,
+        transaction: {
+          ...TRANSACTION_META_MOCK,
+          type: TransactionType.perpsDeposit,
+        } as TransactionMeta,
+      }),
+    ).toBe(true);
+  });
+
+  it('returns true when same-chain swaps are allowed', () => {
+    getPayStrategiesConfigMock.mockReturnValue({
+      across: {
+        allowSameChain: true,
+        apiBase: 'https://across.test',
+        enabled: true,
+      },
+      relay: {
+        enabled: true,
+      },
+    });
+
+    const strategy = new AcrossStrategy();
+    expect(
+      strategy.supports({
+        ...baseRequest,
+        requests: [
+          {
+            from: '0xabc' as Hex,
+            sourceBalanceRaw: '100',
+            sourceChainId: '0x1' as Hex,
+            sourceTokenAddress: '0xabc' as Hex,
+            sourceTokenAmount: '100',
+            targetAmountMinimum: '100',
+            targetChainId: '0x1' as Hex,
+            targetTokenAddress: '0xdef' as Hex,
+          },
+        ],
+      }),
+    ).toBe(true);
+  });
+
+  it('returns false when same-chain swaps are not allowed', () => {
+    const strategy = new AcrossStrategy();
+    expect(
+      strategy.supports({
+        ...baseRequest,
+        requests: [
+          {
+            from: '0xabc' as Hex,
+            sourceBalanceRaw: '100',
+            sourceChainId: '0x1' as Hex,
+            sourceTokenAddress: '0xabc' as Hex,
+            sourceTokenAmount: '100',
+            targetAmountMinimum: '100',
+            targetChainId: '0x1' as Hex,
+            targetTokenAddress: '0xdef' as Hex,
+          },
+        ],
+      }),
+    ).toBe(false);
+  });
+
+  it('returns true when all requests are cross-chain', () => {
+    const strategy = new AcrossStrategy();
+    expect(strategy.supports(baseRequest)).toBe(true);
+  });
+
+  it('delegates getQuotes to across quotes', async () => {
+    const strategy = new AcrossStrategy();
+    const quote = { strategy: 'across' } as TransactionPayQuote<AcrossQuote>;
+    getAcrossQuotesMock.mockResolvedValue([quote]);
+
+    const result = await strategy.getQuotes(baseRequest);
+
+    expect(result).toStrictEqual([quote]);
+    expect(getAcrossQuotesMock).toHaveBeenCalledWith(baseRequest);
+  });
+
+  it('delegates execute to across submit', async () => {
+    const strategy = new AcrossStrategy();
+    const request = {
+      messenger,
+      quotes: [],
+      transaction: TRANSACTION_META_MOCK,
+      isSmartTransaction: jest.fn(),
+    } as PayStrategyExecuteRequest<AcrossQuote>;
+
+    submitAcrossQuotesMock.mockResolvedValue({ transactionHash: '0xhash' });
+
+    const result = await strategy.execute(request);
+
+    expect(result).toStrictEqual({
+      transactionHash: '0xhash',
+    });
+    expect(submitAcrossQuotesMock).toHaveBeenCalledWith(request);
+  });
+});

packages/transaction-pay-controller/src/strategy/across/AcrossStrategy.ts

@@ -0,0 +1,42 @@
+import { getAcrossQuotes } from './across-quotes';
+import { submitAcrossQuotes } from './across-submit';
+import type { AcrossQuote } from './types';
+import type {
+  PayStrategy,
+  PayStrategyExecuteRequest,
+  PayStrategyGetQuotesRequest,
+  TransactionPayQuote,
+} from '../../types';
+import { getPayStrategiesConfig } from '../../utils/feature-flags';
+
+export class AcrossStrategy implements PayStrategy<AcrossQuote> {
+  supports(request: PayStrategyGetQuotesRequest): boolean {
+    const config = getPayStrategiesConfig(request.messenger);
+
+    if (!config.across.enabled) {
+      return false;
+    }
+
+    if (config.across.allowSameChain) {
+      return true;
+    }
+
+    // Across doesn't support same-chain swaps (e.g. mUSD conversions).
+    return request.requests.every(
+      (singleRequest) =>
+        singleRequest.sourceChainId !== singleRequest.targetChainId,
+    );
+  }
+
+  async getQuotes(
+    request: PayStrategyGetQuotesRequest,
+  ): Promise<TransactionPayQuote<AcrossQuote>[]> {
+    return getAcrossQuotes(request);
+  }
+
+  async execute(
+    request: PayStrategyExecuteRequest<AcrossQuote>,
+  ): ReturnType<PayStrategy<AcrossQuote>['execute']> {
+    return submitAcrossQuotes(request);
+  }
+}