fix: preserve transaction type of batched transactions

packages/transaction-controller/CHANGELOG.md

@@ -11,6 +11,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Add fallback to the sequential hook when `publishBatchHook` returns empty ([#6063](https://github.com/MetaMask/core/pull/6063))
 
+### Fixed
+
+- Preserve provided `type` in `transactions` when calling `addTransactionBatch` ([#6056](https://github.com/MetaMask/core/pull/6056))
+
 ## [58.1.1]
 
 ### Changed

packages/transaction-controller/src/TransactionController.ts

@@ -120,6 +120,7 @@ import type {
   AfterSimulateHook,
   BeforeSignHook,
   TransactionContainerType,
+  NestedTransactionMetadata,
 } from './types';
 import {
   GasFeeEstimateLevel,
@@ -1132,7 +1133,7 @@ export class TransactionController extends BaseController<
       deviceConfirmedOn?: WalletDevice;
       disableGasBuffer?: boolean;
       method?: string;
-      nestedTransactions?: BatchTransactionParams[];
+      nestedTransactions?: NestedTransactionMetadata[];
       networkClientId: NetworkClientId;
       origin?: string;
       publishHook?: PublishHook;

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

@@ -370,6 +370,101 @@ describe('Batch Utils', () => {
       expect(result.batchId).toMatch(/^0x[0-9a-f]{32}$/u);
     });
 
+    it('preserves nested transaction types when disable7702 is true', async () => {
+      const publishBatchHook: jest.MockedFn<PublishBatchHook> = jest.fn();
+      mockRequestApproval(MESSENGER_MOCK, {
+        state: 'approved',
+      });
+
+      addTransactionMock
+        .mockResolvedValueOnce({
+          transactionMeta: {
+            ...TRANSACTION_META_MOCK,
+            id: TRANSACTION_ID_MOCK,
+          },
+          result: Promise.resolve(''),
+        })
+        .mockResolvedValueOnce({
+          transactionMeta: {
+            ...TRANSACTION_META_MOCK,
+            id: TRANSACTION_ID_2_MOCK,
+          },
+          result: Promise.resolve(''),
+        });
+      addTransactionBatch({
+        ...request,
+        publishBatchHook,
+        request: {
+          ...request.request,
+          transactions: [
+            {
+              ...request.request.transactions[0],
+              type: TransactionType.swap,
+            },
+            {
+              ...request.request.transactions[1],
+              type: TransactionType.bridge,
+            },
+          ],
+          disable7702: true,
+        },
+      }).catch(() => {
+        // Intentionally empty
+      });
+
+      await flushPromises();
+
+      expect(addTransactionMock).toHaveBeenCalledTimes(2);
+      expect(addTransactionMock.mock.calls[0][1].type).toBe('swap');
+      expect(addTransactionMock.mock.calls[1][1].type).toBe('bridge');
+    });
+
+    it('preserves nested transaction types when disable7702 is false', async () => {
+      const publishBatchHook: jest.MockedFn<PublishBatchHook> = jest.fn();
+
+      isAccountUpgradedToEIP7702Mock.mockResolvedValueOnce({
+        delegationAddress: undefined,
+        isSupported: true,
+      });
+
+      addTransactionMock.mockResolvedValueOnce({
+        transactionMeta: TRANSACTION_META_MOCK,
+        result: Promise.resolve(''),
+      });
+
+      const result = await addTransactionBatch({
+        ...request,
+        publishBatchHook,
+        request: {
+          ...request.request,
+          transactions: [
+            {
+              ...request.request.transactions[0],
+              type: TransactionType.swapApproval,
+            },
+            {
+              ...request.request.transactions[1],
+              type: TransactionType.bridgeApproval,
+            },
+          ],
+          disable7702: false,
+        },
+      });
+
+      expect(result.batchId).toMatch(/^0x[0-9a-f]{32}$/u);
+      expect(addTransactionMock).toHaveBeenCalledTimes(1);
+      expect(addTransactionMock.mock.calls[0][1].type).toStrictEqual(
+        TransactionType.batch,
+      );
+
+      expect(
+        addTransactionMock.mock.calls[0][1].nestedTransactions?.[0].type,
+      ).toBe(TransactionType.swapApproval);
+      expect(
+        addTransactionMock.mock.calls[0][1].nestedTransactions?.[1].type,
+      ).toBe(TransactionType.bridgeApproval);
+    });
+
     it('returns provided batch ID', async () => {
       isAccountUpgradedToEIP7702Mock.mockResolvedValueOnce({
         delegationAddress: undefined,
@@ -837,6 +932,50 @@ describe('Batch Utils', () => {
           PUBLISH_BATCH_HOOK_PARAMS,
         );
       });
+      //   const publishBatchHook: jest.MockedFn<PublishBatchHook> = jest.fn();
+
+      //   addTransactionMock
+      //     .mockResolvedValueOnce({
+      //       transactionMeta: {
+      //         ...TRANSACTION_META_MOCK,
+      //         id: TRANSACTION_ID_MOCK,
+      //       },
+      //       result: Promise.resolve(''),
+      //     })
+      //     .mockResolvedValueOnce({
+      //       transactionMeta: {
+      //         ...TRANSACTION_META_MOCK,
+      //         id: TRANSACTION_ID_2_MOCK,
+      //       },
+      //       result: Promise.resolve(''),
+      //     });
+      //   addTransactionBatch({
+      //     ...request,
+      //     publishBatchHook,
+      //     request: {
+      //       ...request.request,
+      //       transactions: [
+      //         {
+      //           ...request.request.transactions[0],
+      //           type: TransactionType.swap,
+      //         },
+      //         {
+      //           ...request.request.transactions[1],
+      //           type: TransactionType.bridge,
+      //         },
+      //       ],
+      //       disable7702: true,
+      //     },
+      //   }).catch(() => {
+      //     // Intentionally empty
+      //   });
+
+      //   await flushPromises();
+
+      //   expect(addTransactionMock).toHaveBeenCalledTimes(2);
+      //   expect(addTransactionMock.mock.calls[0][1].type).toBe('swap');
+      //   expect(addTransactionMock.mock.calls[1][1].type).toBe('bridge');
+      // });
 
       it('resolves individual publish hooks with transaction hashes from publish batch hook', async () => {
         const publishBatchHook: jest.MockedFn<PublishBatchHook> = jest.fn();

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

@@ -246,13 +246,14 @@ async function getNestedTransactionMeta(
   ethQuery: EthQuery,
 ): Promise<NestedTransactionMetadata> {
   const { from } = request;
-  const { params } = singleRequest;
+  const { params, type: requestedType } = singleRequest;
 
-  const { type } = await determineTransactionType(
+  const { type: determinedType } = await determineTransactionType(
     { from, ...params },
     ethQuery,
   );
 
+  const type = requestedType ?? determinedType;
   return {
     ...params,
     type,
@@ -550,7 +551,7 @@ async function processTransactionWithHook(
   request: AddTransactionBatchRequest,
   txBatchMeta?: TransactionBatchMeta,
 ) {
-  const { existingTransaction, params } = nestedTransaction;
+  const { existingTransaction, params, type } = nestedTransaction;
 
   const {
     addTransaction,
@@ -606,6 +607,7 @@ async function processTransactionWithHook(
       networkClientId,
       publishHook,
       requireApproval: false,
+      type,
     },
   );
 
@@ -626,11 +628,16 @@ async function processTransactionWithHook(
     value,
   };
 
-  log('Processed new transaction with hook', { id, params: newParams });
+  log('Processed new transaction with hook', {
+    id,
+    params: newParams,
+    type,
+  });
 
   return {
     id,
     params: newParams,
+    type,
   };
 }