fix(test): make reorg-based mineEmptyBlock advance L1 time

The v5 mineEmptyBlock rewrite (gas-limit + anvil_reorg, mempool-safe) froze L1
time: anvil stamps a reorg's replacement blocks as parent+N*interval, resetting
the wall-clock advance that the mine step produced. next's gas_price_ladder test
(added after the v5 fork) drives L1 time forward via mineEmptyBlock and asserts
L1TxUtils' stall/timeout ladder; with time frozen, timePassed stays 0, the tx
never times out, and the test hits Jest's 40s wall. Neither public line had both
the new impl and this test, so the collision only surfaced in the forward-port.

Reproduce the wall-clock advance (>=1s per block) through a temporary
block-timestamp interval during the reorg, then restore any pre-existing interval
(read as pending-latest, since anvil exposes no getter) so deploy-set slot
spacing is preserved.

Verified: gas_price_ladder 1/1 (was 40s timeout), eth_cheat_codes 22/22,
l1_tx_utils 51/51.

Author: Thunkar

yarn-project/ethereum/src/test/eth_cheat_codes.ts

@@ -505,19 +505,40 @@ export class EthCheatCodes {
    * reorg is needed because anvil applies a new gas limit only to future blocks: without it the just-mined
    * blocks would keep the tiny gas limit, and an `eth_call` against `latest` (whose gas is capped by the
    * block gas limit) would revert with "intrinsic gas too high".
+   *
+   * The replacement blocks advance L1 time. `anvil_reorg` stamps each replacement as `parent + N*interval`,
+   * so on its own it would freeze L1 time at the parent timestamp; callers that measure elapsed L1 time
+   * (L1TxUtils stall/timeout detection, `syncDateProvider`-driven slot advancement) rely on it moving
+   * forward. We reproduce the wall-clock advance the mine step just made (at least 1s per block) via a
+   * temporary block-timestamp interval, then restore any pre-existing interval.
    */
   public async mineEmptyBlock(blockCount: number = 1): Promise<void> {
     await this.execWithPausedAnvil(async () => {
       const originalGasLimit = await this.getBlockGasLimit();
+      const parentTimestamp = await this.lastBlockTimestamp();
+      // anvil has no getter for the block-timestamp interval, but the pending block is stamped
+      // `latest + interval`, so this delta is the standing interval (0 when none is set).
+      const priorInterval = (await this.nextBlockTimestamp()) - parentTimestamp;
       try {
         await this.setBlockGasLimit(1n);
         await this.doMine(blockCount);
       } finally {
         await this.setBlockGasLimit(originalGasLimit);
       }
+      const advance = (await this.lastBlockTimestamp()) - parentTimestamp;
+      const perBlockInterval = Math.max(1, Math.floor(advance / blockCount));
       // Replace the tiny-gas-limit blocks with empty blocks at the restored gas limit, keeping the same
-      // height and timestamps. The reorged-out blocks held no transactions, so nothing returns to the pool.
-      await this.doRpcCall('anvil_reorg', [blockCount, []]);
+      // height. The reorged-out blocks held no transactions, so nothing returns to the pool.
+      await this.doRpcCall('anvil_setBlockTimestampInterval', [perBlockInterval]);
+      try {
+        await this.doRpcCall('anvil_reorg', [blockCount, []]);
+      } finally {
+        if (priorInterval > 0) {
+          await this.doRpcCall('anvil_setBlockTimestampInterval', [priorInterval]);
+        } else {
+          await this.doRpcCall('anvil_removeBlockTimestampInterval', []);
+        }
+      }
     });
 
     this.logger.warn(`Mined ${blockCount} empty L1 ${pluralize('block', blockCount)}`);