feat: add sequential batch support

Author: vinistevam

packages/transaction-controller/src/TransactionController.ts

@@ -1008,6 +1008,10 @@ export class TransactionController extends BaseController<
       publicKeyEIP7702: this.#publicKeyEIP7702,
       request,
       updateTransaction: this.#updateTransactionInternal.bind(this),
+      publishTransaction: (
+        ethQuery: EthQuery,
+        transactionMeta: TransactionMeta,
+      ) => this.#publishTransaction(ethQuery, transactionMeta) as Promise<Hex>,
     });
   }
 

packages/transaction-controller/src/hooks/SequentialPublishBatchHook.ts

@@ -0,0 +1,162 @@
+import { query } from '@metamask/controller-utils';
+import type EthQuery from '@metamask/eth-query';
+import { rpcErrors } from '@metamask/rpc-errors';
+import { createModuleLogger } from '@metamask/utils';
+import type { Hex } from '@metamask/utils';
+
+import { projectLogger } from '../logger';
+import type {
+  PublishBatchHookTransaction,
+  TransactionMeta,
+  TransactionReceipt,
+} from '../types';
+
+const TRANSACTION_CHECK_INTERVAL = 5000; // 5 seconds
+const MAX_TRANSACTION_CHECK_ATTEMPTS = 60; // 5 minutes
+const RECEIPT_STATUS_SUCCESS = '0x1';
+const RECEIPT_STATUS_FAILURE = '0x0';
+
+const log = createModuleLogger(projectLogger, 'sequential-publish-batch-hook');
+
+type SequentialPublishBatchHookParams = {
+  publishTransaction: (
+    _ethQuery: EthQuery,
+    transactionMeta: TransactionMeta,
+  ) => Promise<Hex>;
+  getTransaction: (id: string) => TransactionMeta;
+  getEthQuery: (networkClientId: string) => EthQuery;
+};
+/**
+ * Custom publish logic that also publishes additional sequential transactions in an batch.
+ * Requires the batch to be successful to resolve.
+ */
+export class SequentialPublishBatchHook {
+  readonly #publishTransaction: (
+    _ethQuery: EthQuery,
+    transactionMeta: TransactionMeta,
+  ) => Promise<Hex>;
+
+  readonly #getTransaction: (id: string) => TransactionMeta;
+
+  readonly #getEthQuery: (networkClientId: string) => EthQuery;
+
+  constructor({
+    publishTransaction,
+    getTransaction,
+    getEthQuery,
+  }: SequentialPublishBatchHookParams) {
+    this.#publishTransaction = publishTransaction;
+    this.#getTransaction = getTransaction;
+    this.#getEthQuery = getEthQuery;
+  }
+
+  /**
+   * Get the hook function for sequential publishing.
+   *
+   * @returns The hook function.
+   */
+  getHook() {
+    return async ({
+      from,
+      networkClientId,
+      transactions,
+    }: {
+      from: string;
+      networkClientId: string;
+      transactions: PublishBatchHookTransaction[];
+    }) => {
+      log('Starting sequential publish batch hook', { from, networkClientId });
+
+      const results = [];
+
+      for (const transaction of transactions) {
+        try {
+          const transactionMeta = this.#getTransaction(String(transaction.id));
+          const transactionHash = await this.#publishTransaction(
+            this.#getEthQuery(networkClientId),
+            transactionMeta,
+          );
+          log('Transaction published', { transactionHash });
+
+          const isConfirmed = await this.#waitForTransactionConfirmation(
+            transactionHash,
+            networkClientId,
+          );
+
+          if (!isConfirmed) {
+            throw new Error(
+              `Transaction ${transactionHash} failed or was not confirmed.`,
+            );
+          }
+
+          results.push({ transactionHash });
+        } catch (error) {
+          log('Transaction failed', { transaction, error });
+          throw rpcErrors.internal(
+            `Failed to publish sequential batch transaction`,
+          );
+        }
+      }
+
+      log('Sequential publish batch hook completed', { results });
+
+      return { results };
+    };
+  }
+
+  async #waitForTransactionConfirmation(
+    transactionHash: string,
+    networkClientId: string,
+  ): Promise<boolean> {
+    let attempts = 0;
+
+    while (attempts < MAX_TRANSACTION_CHECK_ATTEMPTS) {
+      const isConfirmed = await this.#isTransactionConfirmed(
+        transactionHash,
+        networkClientId,
+      );
+
+      if (isConfirmed) {
+        return true;
+      }
+
+      await new Promise((resolve) =>
+        setTimeout(resolve, TRANSACTION_CHECK_INTERVAL),
+      );
+
+      attempts += 1;
+    }
+
+    return false;
+  }
+
+  async #getTransactionReceipt(
+    txHash: string,
+    networkClientId: string,
+  ): Promise<TransactionReceipt | undefined> {
+    return await query(
+      this.#getEthQuery(networkClientId),
+      'getTransactionReceipt',
+      [txHash],
+    );
+  }
+
+  async #isTransactionConfirmed(
+    transactionHash: string,
+    networkClientId: string,
+  ): Promise<boolean> {
+    try {
+      const receipt = await this.#getTransactionReceipt(
+        transactionHash,
+        networkClientId,
+      );
+      const isSuccess = receipt?.status === RECEIPT_STATUS_SUCCESS;
+      const isFailure = receipt?.status === RECEIPT_STATUS_FAILURE;
+
+      return isSuccess || isFailure;
+    } catch (error) {
+      log('Error checking transaction status', { transactionHash, error });
+      return false;
+    }
+  }
+}

packages/transaction-controller/src/utils/batch.ts

@@ -42,6 +42,7 @@ import {
   type TransactionParams,
   TransactionType,
 } from '../types';
+import { SequentialPublishBatchHook } from 'src/hooks/SequentialPublishBatchHook';
 
 type AddTransactionBatchRequest = {
   addTransaction: TransactionController['addTransaction'];
@@ -57,6 +58,10 @@ type AddTransactionBatchRequest = {
     options: { transactionId: string },
     callback: (transactionMeta: TransactionMeta) => void,
   ) => void;
+  publishTransaction: (
+    _ethQuery: EthQuery,
+    transactionMeta: TransactionMeta,
+  ) => Promise<Hex>;
 };
 
 type IsAtomicBatchSupportedRequestInternal = {
@@ -332,7 +337,8 @@ async function getNestedTransactionMeta(
 async function addTransactionBatchWithHook(
   request: AddTransactionBatchRequest,
 ): Promise<TransactionBatchResult> {
-  const { publishBatchHook, request: userRequest } = request;
+  const { publishBatchHook: initialPublishBatchHook, request: userRequest } =
+    request;
 
   const {
     from,
@@ -342,10 +348,14 @@ async function addTransactionBatchWithHook(
 
   log('Adding transaction batch using hook', userRequest);
 
-  if (!publishBatchHook) {
-    log('No publish batch hook provided');
-    throw new Error('No publish batch hook provided');
-  }
+  const sequentialPublishBatchHook = new SequentialPublishBatchHook({
+    publishTransaction: request.publishTransaction,
+    getTransaction: request.getTransaction,
+    getEthQuery: request.getEthQuery,
+  });
+
+  const publishBatchHook =
+    initialPublishBatchHook ?? sequentialPublishBatchHook.getHook();
 
   const batchId = generateBatchId();
   const transactionCount = nestedTransactions.length;