Add Across Perps withdraw support

Author: pedronfigueiredo

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 `perpsAcrossWithdraw` to the `TransactionType` enum ([#8841](https://github.com/MetaMask/core/pull/8841))
+
 ### Changed
 
 - Bump `@metamask/core-backend` from `^6.2.2` to `^6.3.0` ([#8813](https://github.com/MetaMask/core/pull/8813))

packages/transaction-controller/src/types.ts

@@ -814,6 +814,11 @@ export enum TransactionType {
    */
   perpsAcrossDeposit = 'perpsAcrossDeposit',
 
+  /**
+   * Withdraw funds for Across quote via Perps.
+   */
+  perpsAcrossWithdraw = 'perpsAcrossWithdraw',
+
   /**
    * Deposit funds to be available for trading via Perps.
    */

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]
 
+### Added
+
+- Add Across quote and submit support for HyperLiquid-source Perps withdraw flows ([#8841](https://github.com/MetaMask/core/pull/8841))
+
 ### Changed
 
 - Bump `@metamask/gas-fee-controller` from `^26.2.1` to `^26.2.2` ([#8834](https://github.com/MetaMask/core/pull/8834))

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

@@ -249,6 +249,33 @@ describe('AcrossStrategy', () => {
     ).toBe(true);
   });
 
+  it('supports post-quote perps withdraw requests with HyperLiquid source', () => {
+    const strategy = new AcrossStrategy();
+    expect(
+      strategy.supports({
+        ...baseRequest,
+        transaction: {
+          ...TRANSACTION_META_MOCK,
+          type: TransactionType.perpsWithdraw,
+        } as TransactionMeta,
+        requests: [
+          {
+            from: '0xabc' as Hex,
+            isHyperliquidSource: true,
+            isPostQuote: true,
+            sourceBalanceRaw: '100',
+            sourceChainId: CHAIN_ID_ARBITRUM,
+            sourceTokenAddress: ARBITRUM_USDC_ADDRESS,
+            sourceTokenAmount: '100',
+            targetAmountMinimum: '0',
+            targetChainId: CHAIN_ID_ARBITRUM,
+            targetTokenAddress: ARBITRUM_USDC_ADDRESS,
+          },
+        ],
+      }),
+    ).toBe(true);
+  });
+
   it('does not support post-quote requests outside predict withdraw', () => {
     const strategy = new AcrossStrategy();
     expect(

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

@@ -1,5 +1,6 @@
 import { TransactionType } from '@metamask/transaction-controller';
 
+import { createModuleLogger, projectLogger } from '../../logger';
 import type {
   PayStrategy,
   PayStrategyCheckQuoteSupportRequest,
@@ -13,21 +14,30 @@ import { getAcrossDestination } from './across-actions';
 import { getAcrossQuotes } from './across-quotes';
 import { submitAcrossQuotes } from './across-submit';
 import { hasUnsupportedTransactionAuthorizationList } from './authorization-list';
-import { isSupportedAcrossPerpsDepositRequest } from './perps';
+import {
+  isSupportedAcrossPerpsDepositRequest,
+  isSupportedAcrossPerpsWithdrawRequest,
+} from './perps';
 import { isAcrossQuoteRequest } from './requests';
 import type { AcrossQuote } from './types';
 
+const log = createModuleLogger(projectLogger, 'across-strategy');
+
 export class AcrossStrategy implements PayStrategy<AcrossQuote> {
   supports(request: PayStrategyGetQuotesRequest): boolean {
     const config = getPayStrategiesConfig(request.messenger);
 
     if (!config.across.enabled) {
+      log('Across strategy not selected: disabled');
       return false;
     }
 
     const actionableRequests = request.requests.filter(isAcrossQuoteRequest);
 
     if (actionableRequests.length === 0) {
+      log('Across strategy not selected: no actionable Across requests', {
+        requestCount: request.requests.length,
+      });
       return false;
     }
 
@@ -40,16 +50,26 @@ export class AcrossStrategy implements PayStrategy<AcrossQuote> {
       );
 
       if (!supportsPerpsDeposit) {
+        log('Across strategy not selected: unsupported Perps deposit request', {
+          actionableRequests,
+        });
         return false;
       }
     } else {
       // Across doesn't support same-chain swaps (e.g. mUSD conversions).
       const hasSameChainRequest = actionableRequests.some(
         (singleRequest) =>
-          singleRequest.sourceChainId === singleRequest.targetChainId,
+          !isSupportedAcrossPerpsWithdrawRequest(
+            singleRequest,
+            request.transaction,
+          ) && singleRequest.sourceChainId === singleRequest.targetChainId,
       );
 
       if (hasSameChainRequest) {
+        log('Across strategy not selected: same-chain request unsupported', {
+          actionableRequests,
+          transactionType: request.transaction?.type,
+        });
         return false;
       }
     }
@@ -60,18 +80,44 @@ export class AcrossStrategy implements PayStrategy<AcrossQuote> {
         actionableRequests,
       )
     ) {
+      log(
+        'Across strategy not selected: unsupported transaction authorization list',
+        {
+          transactionId: request.transaction?.id,
+          transactionType: request.transaction?.type,
+        },
+      );
       return false;
     }
 
     return actionableRequests.every((singleRequest) => {
       if (singleRequest.isPostQuote) {
-        return isPredictWithdrawTransaction(request.transaction);
+        const isSupported =
+          isPredictWithdrawTransaction(request.transaction) ||
+          isSupportedAcrossPerpsWithdrawRequest(
+            singleRequest,
+            request.transaction,
+          );
+
+        if (!isSupported) {
+          log('Across strategy not selected: unsupported post-quote request', {
+            singleRequest,
+            transactionType: request.transaction?.type,
+          });
+        }
+
+        return isSupported;
       }
 
       try {
         getAcrossDestination(request.transaction, singleRequest);
         return true;
-      } catch {
+      } catch (error) {
+        log('Across strategy not selected: failed to resolve destination', {
+          error,
+          singleRequest,
+          transactionType: request.transaction?.type,
+        });
         return false;
       }
     });

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

@@ -1556,6 +1556,74 @@ describe('Across Quotes', () => {
       expect(getRequestBody().actions).toStrictEqual([]);
     });
 
+    it('converts post-quote perps withdraws from HyperLiquid source to Across HyperCore source quotes', async () => {
+      successfulFetchMock.mockResolvedValue({
+        json: async () => ({
+          ...QUOTE_MOCK,
+          inputAmount: '10000000000',
+          inputToken: {
+            address: ACROSS_HYPERCORE_USDC_PERPS_ADDRESS,
+            chainId: parseInt(CHAIN_ID_HYPERCORE, 16),
+            decimals: 8,
+            symbol: 'USDC',
+          },
+          outputToken: {
+            address: ARBITRUM_USDC_ADDRESS,
+            chainId: parseInt(CHAIN_ID_ARBITRUM, 16),
+            decimals: 6,
+            symbol: 'USDC',
+          },
+        }),
+      } as Response);
+
+      const result = await getAcrossQuotes({
+        accountSupports7702: true,
+        messenger,
+        requests: [
+          {
+            ...QUOTE_REQUEST_MOCK,
+            isHyperliquidSource: true,
+            isPostQuote: true,
+            sourceBalanceRaw: '100000000',
+            sourceChainId: CHAIN_ID_ARBITRUM,
+            sourceTokenAddress: ARBITRUM_USDC_ADDRESS,
+            sourceTokenAmount: '100000000',
+            targetAmountMinimum: '0',
+            targetChainId: CHAIN_ID_ARBITRUM,
+            targetTokenAddress: ARBITRUM_USDC_ADDRESS,
+          },
+        ],
+        transaction: {
+          ...TRANSACTION_META_MOCK,
+          type: TransactionType.perpsWithdraw,
+        } as TransactionMeta,
+      });
+
+      const [url] = successfulFetchMock.mock.calls[0];
+      const params = new URL(url as string).searchParams;
+
+      expect(params.get('amount')).toBe('10000000000');
+      expect(params.get('tradeType')).toBe('exactInput');
+      expect(params.get('originChainId')).toBe(
+        String(parseInt(CHAIN_ID_HYPERCORE, 16)),
+      );
+      expect(params.get('inputToken')).toBe(
+        ACROSS_HYPERCORE_USDC_PERPS_ADDRESS,
+      );
+      expect(params.get('recipient')).toBe(FROM_MOCK);
+      expect(getRequestBody().actions).toStrictEqual([]);
+      expect(result[0].request.sourceBalanceRaw).toBe('10000000000');
+      expect(result[0].request.sourceChainId).toBe(CHAIN_ID_HYPERCORE);
+      expect(result[0].request.sourceTokenAddress).toBe(
+        ACROSS_HYPERCORE_USDC_PERPS_ADDRESS,
+      );
+      expect(getTokenFiatRateMock).toHaveBeenCalledWith(
+        expect.anything(),
+        ARBITRUM_USDC_ADDRESS,
+        CHAIN_ID_ARBITRUM,
+      );
+    });
+
     it('uses transfer recipient for token transfer transactions', async () => {
       const transferData = buildTransferData(TRANSFER_RECIPIENT);
 

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

@@ -4,7 +4,11 @@ import type { Hex } from '@metamask/utils';
 import { createModuleLogger } from '@metamask/utils';
 import { BigNumber } from 'bignumber.js';
 
-import { TransactionPayStrategy } from '../../constants';
+import {
+  ARBITRUM_USDC_ADDRESS,
+  CHAIN_ID_ARBITRUM,
+  TransactionPayStrategy,
+} from '../../constants';
 import { projectLogger } from '../../logger';
 import type {
   Amount,
@@ -98,7 +102,7 @@ async function getSingleQuote(
   fullRequest: PayStrategyGetQuotesRequest,
 ): Promise<TransactionPayQuote<AcrossQuote>> {
   const { messenger, signal, transaction } = fullRequest;
-  const normalizedRequest = normalizeAcrossRequest(request, transaction.type);
+  const normalizedRequest = normalizeAcrossRequest(request, transaction);
   const {
     from,
     isMaxAmount,
@@ -334,9 +338,14 @@ async function requestAcrossApproval(
     signal,
   };
 
+  log('Calling Across approval endpoint', { body, url });
+
   const response = await successfulFetch(url, options);
+  const approval = (await response.json()) as AcrossSwapApprovalResponse;
 
-  return (await response.json()) as AcrossSwapApprovalResponse;
+  log('Received Across approval response', approval);
+
+  return approval;
 }
 
 async function normalizeQuote(
@@ -350,6 +359,7 @@ async function normalizeQuote(
   const { usdToFiatRate, sourceFiatRate, targetFiatRate } = getFiatRates(
     messenger,
     quote,
+    request,
   );
 
   const dustUsd = calculateDustUsd(quote, request, targetFiatRate);
@@ -434,15 +444,26 @@ async function normalizeQuote(
 function getFiatRates(
   messenger: TransactionPayControllerMessenger,
   quote: AcrossSwapApprovalResponse,
+  request: QuoteRequest,
 ): {
   sourceFiatRate: FiatRates;
   targetFiatRate: FiatRates;
   usdToFiatRate: BigNumber;
 } {
+  // HyperLiquid source requests are normalized to HyperCore USDC-PERPS, which
+  // may not have a local fiat-rate entry. Use Arbitrum USDC as the 1:1 price
+  // anchor, matching the Relay HyperLiquid-source flow.
+  const sourceChainId = request.isHyperliquidSource
+    ? CHAIN_ID_ARBITRUM
+    : toHex(quote.inputToken.chainId);
+  const sourceTokenAddress = request.isHyperliquidSource
+    ? ARBITRUM_USDC_ADDRESS
+    : quote.inputToken.address;
+
   const sourceFiatRate = getTokenFiatRate(
     messenger,
-    quote.inputToken.address,
-    toHex(quote.inputToken.chainId),
+    sourceTokenAddress,
+    sourceChainId,
   );
 
   if (!sourceFiatRate) {
@@ -678,7 +699,9 @@ async function calculateSourceNetworkCost(
     totalGasLimit: gasEstimates.totalGasLimit,
   };
 
-  const finalResult = request.isPostQuote
+  const shouldIncludeOriginalPostQuoteGas =
+    request.isPostQuote === true && request.isHyperliquidSource !== true;
+  const finalResult = shouldIncludeOriginalPostQuoteGas
     ? combinePostQuoteGas(result, transaction, swapTx, messenger)
     : result;
 
@@ -733,7 +756,7 @@ async function calculateSourceNetworkCost(
     },
     totalGasEstimate: finalResult.totalGasEstimate,
     totalItemCount: Math.max(
-      orderedTransactions.length + (request.isPostQuote ? 1 : 0),
+      orderedTransactions.length + (shouldIncludeOriginalPostQuoteGas ? 1 : 0),
       finalResult.gasLimits.length,
     ),
   });