refactor(transaction-controller): extract getProvidedBatchGasLimits helper

Both branches of `estimateGasBatch` (EIP-7702 and non-7702) now share a
single helper that returns parsed limits + sum when every transaction
has a provided `gas`, or `undefined` otherwise.

Adds a focused `describe('getProvidedBatchGasLimits')` block covering:
- all transactions have gas
- none have gas
- mixed (some have gas)
- hex gas values
- empty batch (documents current behaviour)

No behavioural change.

Author: dan437

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

@@ -23,6 +23,7 @@ import {
   addGasBuffer,
   estimateGas,
   estimateGasBatch,
+  getProvidedBatchGasLimits,
   updateGas,
   FIXED_GAS,
   DEFAULT_GAS_MULTIPLIER,
@@ -1548,6 +1549,48 @@ describe('gas', () => {
     });
   });
 
+  describe('getProvidedBatchGasLimits', () => {
+    it('returns parsed limits + sum when every transaction has a gas value', () => {
+      expect(
+        getProvidedBatchGasLimits(BATCH_TX_PARAMS_WITH_GAS_MOCK),
+      ).toStrictEqual({
+        gasLimits: [21000, 500000],
+        totalGasLimit: 521000,
+      });
+    });
+
+    it('returns undefined when none of the transactions have gas', () => {
+      expect(getProvidedBatchGasLimits(BATCH_TX_PARAMS_MOCK)).toBeUndefined();
+    });
+
+    it('returns undefined when only some transactions have gas', () => {
+      const mixed = [BATCH_TX_PARAMS_WITH_GAS_MOCK[0], BATCH_TX_PARAMS_MOCK[0]];
+      expect(getProvidedBatchGasLimits(mixed)).toBeUndefined();
+    });
+
+    it('parses hex gas values correctly', () => {
+      const txWithHexGas = [
+        { ...BATCH_TX_PARAMS_MOCK[0], gas: '0x5208' as Hex },
+        { ...BATCH_TX_PARAMS_MOCK[1], gas: '0x7a120' as Hex },
+      ];
+      expect(getProvidedBatchGasLimits(txWithHexGas)).toStrictEqual({
+        gasLimits: [21000, 500000],
+        totalGasLimit: 521000,
+      });
+    });
+
+    it('returns zero-length result for an empty batch', () => {
+      // `every` on empty array returns true, so the function returns a valid
+      // (but empty) result rather than `undefined`. Callers of `estimateGasBatch`
+      // always pass at least one transaction, so this is documenting current
+      // behaviour rather than a guarantee.
+      expect(getProvidedBatchGasLimits([])).toStrictEqual({
+        gasLimits: [],
+        totalGasLimit: 0,
+      });
+    });
+  });
+
   describe('simulateGasBatch', () => {
     it('returns the total gas limit as a hex string', async () => {
       simulateTransactionsMock.mockResolvedValueOnce(

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

@@ -208,6 +208,38 @@ export async function estimateGas({
   };
 }
 
+/**
+ * Honour caller-provided gas limits without simulating.
+ *
+ * If every transaction in the batch already has a `gas` value, returns the
+ * parsed per-tx limits and their sum. Otherwise returns `undefined` so the
+ * caller falls back to simulation.
+ *
+ * Used by both branches of `estimateGasBatch` (EIP-7702 and non-7702) — required
+ * for callers that submit batches whose individual sub-calls cannot be simulated
+ * standalone (e.g. predict-withdraw, where the batch's first sub-call provides
+ * source-token balance to subsequent sub-calls (approve + swap), and simulating
+ * the relay-only sub-calls in isolation reverts because the caller has no
+ * balance until the first sub-call has run).
+ *
+ * @param transactions - Batch transactions to inspect.
+ * @returns Parsed gas limits and total when every transaction has gas; otherwise `undefined`.
+ */
+export function getProvidedBatchGasLimits(
+  transactions: BatchTransactionParams[],
+): { gasLimits: number[]; totalGasLimit: number } | undefined {
+  if (!transactions.every((transaction) => transaction.gas !== undefined)) {
+    return undefined;
+  }
+
+  const gasLimits = transactions.map((transaction) =>
+    new BigNumber(transaction.gas as Hex).toNumber(),
+  );
+  const totalGasLimit = gasLimits.reduce((acc, gasLimit) => acc + gasLimit, 0);
+
+  return { gasLimits, totalGasLimit };
+}
+
 export async function estimateGasBatch({
   from,
   getSimulationConfig,
@@ -245,34 +277,13 @@ export async function estimateGasBatch({
   }
 
   if (chainResult) {
-    // If the caller already provided a gas limit on every transaction, trust
-    // them and skip simulation. This matches the non-7702 path's behaviour
-    // below and is essential for callers that submit batches whose individual
-    // calls cannot be simulated standalone — e.g. predict-withdraw, where the
-    // batch's first sub-call (Safe.execTransaction) provides source-token
-    // balance to subsequent sub-calls (approve + swap), and simulating the
-    // relay-only sub-calls in isolation reverts because the EOA has no
-    // balance until the Safe sub-call has run.
-    const allTransactionsHaveGas = transactions.every(
-      (transaction) => transaction.gas !== undefined,
-    );
-
-    if (allTransactionsHaveGas) {
-      const gasLimits = transactions.map((transaction) =>
-        new BigNumber(transaction.gas as Hex).toNumber(),
-      );
-      const totalGasLimit = gasLimits.reduce(
-        (acc, gasLimit) => acc + gasLimit,
-        0,
-      );
-      log('Using batch parameter gas limits (7702 path)', {
-        gasLimits,
-        totalGasLimit,
-      });
+    const providedBatchGasLimits = getProvidedBatchGasLimits(transactions);
+    if (providedBatchGasLimits) {
+      log('Using batch parameter gas limits (7702 path)', providedBatchGasLimits);
       return {
-        gasLimits: [totalGasLimit],
+        gasLimits: [providedBatchGasLimits.totalGasLimit],
         ...(isUpgradeRequired ? { requiresAuthorizationList: true } : {}),
-        totalGasLimit,
+        totalGasLimit: providedBatchGasLimits.totalGasLimit,
       };
     }
 
@@ -310,20 +321,10 @@ export async function estimateGasBatch({
     };
   }
 
-  const allTransactionsHaveGas = transactions.every(
-    (transaction) => transaction.gas !== undefined,
-  );
-
-  if (allTransactionsHaveGas) {
-    const gasLimits = transactions.map((transaction) =>
-      new BigNumber(transaction.gas as Hex).toNumber(),
-    );
-
-    const total = gasLimits.reduce((acc, gasLimit) => acc + gasLimit, 0);
-
-    log('Using batch parameter gas limits', { gasLimits, total });
-
-    return { totalGasLimit: total, gasLimits };
+  const providedBatchGasLimits = getProvidedBatchGasLimits(transactions);
+  if (providedBatchGasLimits) {
+    log('Using batch parameter gas limits', providedBatchGasLimits);
+    return providedBatchGasLimits;
   }
 
   const { gasLimits: gasLimitsHex } = await simulateGasBatch({