test: v2

Author: micaelae

packages/bridge-status-controller/src/bridge-status-controller.ts

@@ -34,7 +34,7 @@ import {
   MAX_ATTEMPTS,
   REFRESH_INTERVAL_MS,
 } from './constants';
-import selectSubmitStrategy from './submit-flows';
+import { executeApproval, executeBatch, executeTrade } from './submit-flows';
 import type {
   BridgeStatusControllerState,
   StartPollingForBridgeTxStatusArgsSerialized,
@@ -890,9 +890,12 @@ export class BridgeStatusController extends StaticIntervalPollingController<Brid
 
     const startTime = Date.now();
 
-    const tradeMeta = await this.#trace(
+    return await this.#trace(
       getTraceParams(quoteResponse, isStxEnabledOnClient),
-      async (): Promise<TransactionMeta | undefined> => {
+      async () => {
+        let tradeTxMeta: TransactionMeta | undefined;
+        let approvalTxId: string | undefined;
+
         try {
           const isBridgeTx = isCrossChain(
             quoteResponse.quote.srcChainId,
@@ -917,12 +920,6 @@ export class BridgeStatusController extends StaticIntervalPollingController<Brid
                 [formatChainIdToHex(quoteResponse.quote.srcChainId)],
               );
 
-          const submitStrategy = selectSubmitStrategy({
-            quoteResponse,
-            isStxEnabledOnClient,
-            isDelegatedAccount,
-          });
-
           const params = {
             quoteResponse,
             isStxEnabledOnClient,
@@ -937,39 +934,71 @@ export class BridgeStatusController extends StaticIntervalPollingController<Brid
             fetchFn: this.#fetchFn,
             bridgeApiBaseUrl: this.#config.customBridgeApiBaseUrl,
           };
-          const execute = submitStrategy.execute(params);
-
-          let tradeTxMeta: TransactionMeta | undefined;
-
-          // Each submission strategy determines when to return values, which means these values can be returned in any order
-          for await (const value of execute) {
-            if (value.historyItem) {
-              this.#addTxToHistory({
-                ...value.historyItem,
-                quoteResponse,
-                accountAddress: selectedAccount.address,
-                isStxEnabled: isStxEnabledOnClient,
-                startTime,
-                location,
-                abTests,
-                activeAbTests,
-                slippagePercentage: 0, // TODO include slippage provided by quote if using dynamic slippage, or slippage from quote request
-              });
-            }
-            if (value.tradeMeta) {
-              this.#rekeyHistoryItem(actionId, value.tradeMeta);
-              tradeTxMeta = value.tradeMeta;
-            }
-            if (value.pollingToken) {
-              this.#startPollingForTxId(value.pollingToken);
-            }
-            if (value.completedEventPayload) {
-              this.#trackUnifiedSwapBridgeEvent(
-                UnifiedSwapBridgeEventName.Completed,
-                value.completedEventPayload,
-              );
-            }
+
+          const partialHistoryItem = {
+            quoteResponse,
+            accountAddress: selectedAccount.address,
+            isStxEnabled: isStxEnabledOnClient,
+            startTime,
+            location,
+            abTests,
+            activeAbTests,
+            slippagePercentage: 0, // TODO include slippage provided by quote if using dynamic slippage, or slippage from quote request
+          };
+
+          const {
+            tradeMeta: batchTradeTxMeta,
+            approvalTxId: batchApprovalTxId,
+          } = await executeBatch(params);
+          if (batchApprovalTxId) {
+            approvalTxId = batchApprovalTxId;
+          }
+          if (batchTradeTxMeta) {
+            tradeTxMeta = batchTradeTxMeta;
+            this.#addTxToHistory({
+              bridgeTxMeta: tradeTxMeta,
+              approvalTxId,
+              ...partialHistoryItem,
+            });
+          }
+
+          const { approvalTxId: approvalTxIdResult } =
+            await executeApproval(params);
+          if (approvalTxIdResult) {
+            approvalTxId = approvalTxIdResult;
+            this.#addTxToHistory({
+              approvalTxId,
+              ...partialHistoryItem,
+            });
+          }
+
+          const {
+            tradeMeta: tradeTxMetaResult,
+            pollingToken,
+            completedEventPayload,
+          } = await executeTrade(params);
+          if (tradeTxMetaResult) {
+            tradeTxMeta = tradeTxMetaResult;
+            this.#rekeyHistoryItem(actionId, tradeTxMetaResult);
+            // TODO this should onkly happen if there was no prior approval, check for actionId
+            this.#addTxToHistory({
+              approvalTxId,
+              bridgeTxMeta: tradeTxMeta,
+              ...partialHistoryItem,
+            });
+          }
+
+          if (pollingToken) {
+            this.#startPollingForTxId(pollingToken);
+          }
+          if (completedEventPayload) {
+            this.#trackUnifiedSwapBridgeEvent(
+              UnifiedSwapBridgeEventName.Completed,
+              tradeTxMeta?.id,
+              completedEventPayload,
+            );
           }
+
           return tradeTxMeta;
         } catch (error) {
           !quoteResponse.featureId &&
@@ -982,16 +1011,13 @@ export class BridgeStatusController extends StaticIntervalPollingController<Brid
               },
             );
         }
+        if (!tradeTxMeta) {
+          throw new Error(
+            'Failed to submit cross-chain swap transaction: no trade meta found',
+          );
+        }
       },
     );
-
-    if (!tradeMeta) {
-      throw new Error(
-        'Failed to submit cross-chain swap transaction: no trade meta found',
-      );
-    }
-
-    return tradeMeta;
   };
 
   /**

packages/bridge-status-controller/src/submit-flows/batch.ts

@@ -2,11 +2,7 @@
 /* eslint-disable @typescript-eslint/prefer-nullish-coalescing */
 import { isEvmTxData } from '@metamask/bridge-controller';
 
-import {
-  SubmissionResultGenerator,
-  MatchesFlow,
-  SubmitStrategy,
-} from './types';
+import { MatchesFlow, SubmitStrategy, ExecuteParams } from './types';
 import {
   addTransactionBatch,
   getAddTransactionBatchParams,
@@ -17,6 +13,10 @@ const matchesFlow: MatchesFlow = ({
   isStxEnabledOnClient,
   isDelegatedAccount,
 }) => {
+  // TODO support intent approvals
+  if (quoteResponse.quote.intent) {
+    return false;
+  }
   return (
     isStxEnabledOnClient ||
     quoteResponse.quote.gasIncluded7702 ||
@@ -32,14 +32,14 @@ const matchesFlow: MatchesFlow = ({
  * @param args.quoteResponse - The quote response
  * @param args.messenger - The messenger
  * @param args.requireApproval - Whether to require approval for the transaction
- * @yields The approvalMeta and tradeMeta for the batched transaction
+ * @returns The approvalMeta and tradeMeta for the batched transaction
  */
-async function* submitBatchHandler({
+const executeBatch = async ({
   requireApproval,
   quoteResponse,
   messenger,
   isBridgeTx,
-}: Parameters<SubmissionResultGenerator>[0]) {
+}: ExecuteParams) => {
   if (!isEvmTxData(quoteResponse.trade)) {
     throw new Error(
       'Failed to submit cross-chain swap transaction: trade is not an EVM transaction',
@@ -62,18 +62,13 @@ async function* submitBatchHandler({
     messenger,
     transactionParams,
   );
-  yield {
+  return {
     tradeMeta,
-    historyItem: {
-      approvalTxId: approvalMeta?.id,
-      bridgeTxMeta: tradeMeta, // Only the id field is used by the BridgeStatusController
-      quoteResponse,
-      slippagePercentage: 0, // TODO include slippage provided by quote if using dynamic slippage, or slippage from quote request
-    },
+    approvalTxId: approvalMeta?.id,
   };
-}
+};
 
 export const submitBatch: SubmitStrategy = {
   matchesFlow,
-  execute: submitBatchHandler,
+  executeBatch,
 };

packages/bridge-status-controller/src/submit-flows/evm.ts

@@ -1,19 +1,28 @@
+/* eslint-disable @typescript-eslint/prefer-nullish-coalescing */
 /* eslint-disable @typescript-eslint/explicit-function-return-type */
 import { isEvmTxData } from '@metamask/bridge-controller';
 import { TransactionType } from '@metamask/transaction-controller';
 
-import {
-  SubmissionResultGenerator,
-  SubmitStrategy,
-  ExecuteParams,
-} from './types';
+import { SubmitStrategy, ExecuteParams, MatchesFlow } from './types';
 import { getApprovalTraceParams } from '../utils/trace';
 import {
   handleApprovalDelay,
   handleMobileHardwareWalletDelay,
   submitEvmTransaction,
 } from '../utils/transaction';
 
+const matchesFlow: MatchesFlow = ({
+  quoteResponse,
+  isStxEnabledOnClient,
+  isDelegatedAccount,
+}) => {
+  return !(
+    isStxEnabledOnClient ||
+    quoteResponse.quote.gasIncluded7702 ||
+    isDelegatedAccount
+  );
+};
+
 export const handleApprovalTx = async ({
   quoteResponse,
   messenger,
@@ -28,6 +37,7 @@ export const handleApprovalTx = async ({
   if (!approval || !isEvmTxData(approval)) {
     return {};
   }
+
   if (resetApproval) {
     await submitEvmTransaction({
       messenger,
@@ -50,41 +60,15 @@ export const handleApprovalTx = async ({
   return { approvalTxId: approvalTxMeta?.id };
 };
 
-async function* submitEvmHandler(
-  ...args: Parameters<SubmissionResultGenerator>
-) {
-  const {
-    quoteResponse,
-    messenger,
-    traceFn,
-    isBridgeTx,
-    requireApproval,
-    actionId,
-    isStxEnabledOnClient,
-  } = args[0];
+const handleTradeTx = async (args: ExecuteParams) => {
+  const { quoteResponse, messenger, isBridgeTx, requireApproval, actionId } =
+    args;
   if (!isEvmTxData(quoteResponse.trade)) {
     throw new Error(
       'Failed to submit cross-chain swap transaction: trade is not an EVM transaction',
     );
   }
 
-  // Set approval time and id if an approval tx is needed
-  const { approvalTxId } = await traceFn(
-    getApprovalTraceParams(quoteResponse, isStxEnabledOnClient),
-    async () => {
-      return await handleApprovalTx(...args);
-    },
-  );
-
-  // Add pre-submission history keyed by actionId
-  // This ensures we have quote data available if transaction fails during submission
-  // Set approval time and id if an approval tx is needed
-  yield {
-    historyItem: {
-      approvalTxId,
-    },
-  };
-
   // Pass txFee when gasIncluded is true to use the quote's gas fees
   // instead of re-estimating (which would fail for max native token swaps)
   const tradeMeta = await submitEvmTransaction({
@@ -98,10 +82,15 @@ async function* submitEvmHandler(
     actionId,
   });
 
-  yield { approvalTxId, tradeMeta };
-}
+  return { tradeMeta };
+};
 
 export const defaultSubmitHandler: SubmitStrategy = {
-  matchesFlow: () => true,
-  execute: submitEvmHandler,
+  matchesFlow,
+  executeApproval: async (args) =>
+    await args.traceFn(
+      getApprovalTraceParams(args.quoteResponse, args.isStxEnabledOnClient),
+      async () => handleApprovalTx(args),
+    ),
+  executeTrade: handleTradeTx,
 };