fix: add coverage to gas

Author: vinistevam

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

@@ -28,10 +28,7 @@ import {
 } from '..';
 import { flushPromises } from '../../../../tests/helpers';
 import { SequentialPublishBatchHook } from '../hooks/SequentialPublishBatchHook';
-import type {
-  PublishBatchHook,
-  TransactionBatchSingleRequest,
-} from '../types';
+import type { PublishBatchHook, TransactionBatchSingleRequest } from '../types';
 
 jest.mock('./eip7702');
 jest.mock('./feature-flags');
@@ -1518,24 +1515,21 @@ describe('Batch Utils', () => {
           expect.objectContaining({
             id: expect.any(String),
             chainId: CHAIN_ID_MOCK,
+            gas: GAS_TOTAL_MOCK,
+            from: FROM_MOCK,
             networkClientId: NETWORK_CLIENT_ID_MOCK,
             transactions: [
-              expect.objectContaining({
-                params: {
-                  data: DATA_MOCK,
-                  to: TO_MOCK,
-                  value: VALUE_MOCK,
-                },
-              }),
-              expect.objectContaining({
-                params: {
-                  data: DATA_MOCK,
-                  to: TO_MOCK,
-                  value: VALUE_MOCK,
-                },
-              }),
+              {
+                params: TRANSACTION_BATCH_PARAMS_MOCK,
+                type: TransactionType.contractInteraction,
+              },
+              {
+                params: TRANSACTION_BATCH_PARAMS_MOCK,
+                type: TransactionType.contractInteraction,
+              },
             ],
             origin: ORIGIN_MOCK,
+            time: expect.any(Number),
           }),
         ]);
 

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

@@ -420,7 +420,6 @@ async function addTransactionBatchWithHook(
           transactions: nestedTransactions,
         });
 
-      console.log('1 nestedTransactions before >>>>', nestedTransactions);
       // resigned the transactions with simulated gas
       nestedTransactions = transactionsWithGas;
 
@@ -434,7 +433,7 @@ async function addTransactionBatchWithHook(
         from,
         gas: gasLimit,
       });
-
+      console.log('1 txBatchMeta >>>>', txBatchMeta?.transactions?.[0]);
       addBatchMetadata(txBatchMeta, update);
 
       resultCallbacks = (await requestApproval(txBatchMeta, messenger))

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

@@ -15,12 +15,19 @@ import {
   MAX_GAS_BLOCK_PERCENT,
   INTRINSIC_GAS,
   DUMMY_AUTHORIZATION_SIGNATURE,
+  simulateGasBatch,
 } from './gas';
-import type { SimulationResponse } from '../api/simulation-api';
+import type {
+  SimulationResponse,
+  SimulationResponseTransaction,
+} from '../api/simulation-api';
 import { simulateTransactions } from '../api/simulation-api';
 import type { TransactionControllerMessenger } from '../TransactionController';
 import { TransactionEnvelopeType, type TransactionMeta } from '../types';
-import type { AuthorizationList } from '../types';
+import type {
+  AuthorizationList,
+  TransactionBatchSingleRequest,
+} from '../types';
 
 jest.mock('@metamask/controller-utils', () => ({
   ...jest.requireActual('@metamask/controller-utils'),
@@ -861,4 +868,146 @@ describe('gas', () => {
       expect(result).toBe(toHex(maxGasLimit));
     });
   });
+
+  describe('simulateGasBatch', () => {
+    const FROM_MOCK = '0xabc';
+    const TO_MOCK = '0xdef';
+    const VALUE_MOCK = '0x1';
+    const VALUE_MOCK_2 = '0x2';
+    const DATA_MOCK = '0xabcdef';
+    const DATA_MOCK_2 = '0x123456';
+    const GAS_MOCK_1 = '0x5208'; // 21000 gas
+    const GAS_MOCK_2 = '0x7a120'; // 500000 gas
+    const TRANSACTION_BATCH_REQUEST_MOCK = [
+      {
+        params: {
+          data: DATA_MOCK,
+          to: TO_MOCK,
+          value: VALUE_MOCK,
+        },
+      },
+      {
+        params: {
+          data: DATA_MOCK_2,
+          to: TO_MOCK,
+          value: VALUE_MOCK_2,
+        },
+      },
+    ] as TransactionBatchSingleRequest[];
+
+    const SIMULATED_TRANSACTIONS_RESPONSE_MOCK = {
+      transactions: [{ gasLimit: GAS_MOCK_1 }, { gasLimit: GAS_MOCK_2 }],
+    } as unknown as SimulationResponse;
+
+    beforeEach(() => {
+      jest.resetAllMocks();
+    });
+
+    it('returns simulated gas limits for each transaction and the total gas limit', async () => {
+      simulateTransactionsMock.mockResolvedValueOnce(
+        SIMULATED_TRANSACTIONS_RESPONSE_MOCK,
+      );
+
+      const result = await simulateGasBatch({
+        chainId: CHAIN_ID_MOCK,
+        from: FROM_MOCK,
+        transactions: TRANSACTION_BATCH_REQUEST_MOCK,
+      });
+
+      expect(result).toStrictEqual({
+        transactions: [
+          {
+            ...TRANSACTION_BATCH_REQUEST_MOCK[0],
+            params: {
+              ...TRANSACTION_BATCH_REQUEST_MOCK[0].params,
+              gas: GAS_MOCK_1,
+            },
+          },
+          {
+            ...TRANSACTION_BATCH_REQUEST_MOCK[1],
+            params: {
+              ...TRANSACTION_BATCH_REQUEST_MOCK[1].params,
+              gas: GAS_MOCK_2,
+            },
+          },
+        ],
+        gasLimit: '0x7f328', // Total gas limit (21000 + 500000 = 521000)
+      });
+
+      expect(simulateTransactionsMock).toHaveBeenCalledTimes(1);
+      expect(simulateTransactionsMock).toHaveBeenCalledWith(CHAIN_ID_MOCK, {
+        transactions: [
+          {
+            ...TRANSACTION_BATCH_REQUEST_MOCK[0].params,
+            from: FROM_MOCK,
+          },
+          {
+            ...TRANSACTION_BATCH_REQUEST_MOCK[1].params,
+            from: FROM_MOCK,
+          },
+        ],
+      });
+    });
+
+    it('throws an error if the simulated response does not match the number of transactions', async () => {
+      simulateTransactionsMock.mockResolvedValueOnce({
+        transactions: [
+          { gasLimit: GAS_MOCK_1 } as unknown as SimulationResponseTransaction,
+        ], // Only one transaction returned
+      });
+
+      await expect(
+        simulateGasBatch({
+          chainId: CHAIN_ID_MOCK,
+          from: FROM_MOCK,
+          transactions: TRANSACTION_BATCH_REQUEST_MOCK,
+        }),
+      ).rejects.toThrow(
+        'Simulated gas response does not match the number of transactions',
+      );
+
+      expect(simulateTransactionsMock).toHaveBeenCalledTimes(1);
+    });
+
+    it('throws an error if no simulated gas is returned for a transaction', async () => {
+      simulateTransactionsMock.mockResolvedValueOnce({
+        transactions: [
+          { gasLimit: undefined },
+          { gasLimit: GAS_MOCK_2 },
+        ] as unknown as SimulationResponseTransaction[],
+      });
+
+      await expect(
+        simulateGasBatch({
+          chainId: CHAIN_ID_MOCK,
+          from: FROM_MOCK,
+          transactions: TRANSACTION_BATCH_REQUEST_MOCK,
+        }),
+      ).rejects.toThrow('No simulated gas returned');
+
+      expect(simulateTransactionsMock).toHaveBeenCalledTimes(1);
+    });
+
+    it('handles empty transactions gracefully', async () => {
+      simulateTransactionsMock.mockResolvedValueOnce({
+        transactions: [],
+      });
+
+      const result = await simulateGasBatch({
+        chainId: CHAIN_ID_MOCK,
+        from: FROM_MOCK,
+        transactions: [],
+      });
+
+      expect(result).toStrictEqual({
+        transactions: [],
+        gasLimit: '0x0', // Total gas limit is 0
+      });
+
+      expect(simulateTransactionsMock).toHaveBeenCalledTimes(1);
+      expect(simulateTransactionsMock).toHaveBeenCalledWith(CHAIN_ID_MOCK, {
+        transactions: [],
+      });
+    });
+  });
 });