@aztec-labs/ethereum 6.0.0-rc.3 → 6.0.0

package/src/test/anvil_hardfork.ts

@@ -0,0 +1,95 @@
+import { Buffer } from 'buffer';
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { gunzipSync } from 'node:zlib';
+import { type EIP1193RequestFn, type Hex, createPublicClient, http } from 'viem';
+
+import { resolveFoundryBinary } from '../foundry_binary.js';
+import { isAmsterdamBlock } from '../l1_tx_utils/amsterdam.js';
+import type { EthCheatCodes } from './eth_cheat_codes.js';
+import { type Anvil, startAnvil } from './start_anvil.js';
+
+/**
+ * Starts a throwaway anvil on `hardfork` and checks that it mines blocks of that fork, so a test that needs a fork
+ * the installed foundry cannot run fails within seconds instead of after its whole setup. Never skips.
+ */
+export async function assertAnvilSupportsHardfork(hardfork: string): Promise<void> {
+  let res: Awaited<ReturnType<typeof startAnvil>> | undefined;
+  try {
+    res = await startAnvil({ port: 0, hardfork });
+    const client = createPublicClient({ transport: http(res.rpcUrl, { batch: false }) });
+    await client.request({ method: 'evm_mine' as any, params: [] as any });
+    const block = await client.getBlock({ blockTag: 'latest' });
+    if (isAmsterdamBlock(block) !== (hardfork === 'amsterdam')) {
+      throw new Error(`anvil --hardfork ${hardfork} mined block ${block.number} with the wrong header shape`);
+    }
+  } catch (err) {
+    throw new Error(
+      `Anvil at ${resolveFoundryBinary('anvil')} cannot run --hardfork ${hardfork}; foundry >= 1.8.5 is required`,
+      { cause: err },
+    );
+  } finally {
+    await res?.stop();
+  }
+}
+
+/**
+ * Writes anvil's state, including the historical states it still keeps, as the plain JSON file `--load-state` reads.
+ * Without history, reads at blocks before a restart fail on the reloaded anvil. A dump with history easily exceeds
+ * viem's default response size limit, so `client` must be one built without it, such as `createExtendedL1Client`'s.
+ */
+export async function dumpAnvilStateWithHistory(client: { request: EIP1193RequestFn }, path: string): Promise<void> {
+  const hex = await client.request<{ Method: 'anvil_dumpState'; Parameters: [boolean]; ReturnType: Hex }>({
+    method: 'anvil_dumpState',
+    params: [true],
+  });
+  const dump = Buffer.from(hex.slice(2), 'hex');
+  const isGzip = dump[0] === 0x1f && dump[1] === 0x8b;
+  // Kept as a Buffer: a dump with history can exceed the maximum length of a V8 string.
+  await writeFile(path, isGzip ? gunzipSync(dump) : dump);
+}
+
+/**
+ * Moves an interval-mining anvil to another hardfork, continuing its chain. Anvil cannot change hardfork at runtime,
+ * so this stops mining, dumps the state with history to `stateDir` using `dumpClient`, stops `anvil`, and starts a new
+ * anvil on the same port from the dump with `startOpts`. Mining stays stopped until the old anvil is gone, so no block
+ * mined after the dump is lost. Pending txs are lost, since the mempool is not part of the dump.
+ *
+ * The reloaded anvil would stamp its next block as if no time had passed since the dump, so the first block on the new
+ * hardfork is mined at the first L1 slot of the old chain's grid that is not in the past, and interval mining resumes
+ * from there.
+ *
+ * @returns The new anvil, which replaces `anvil`, and the first block mined on `hardfork`.
+ */
+export async function restartAnvilOnHardfork(
+  anvil: Anvil,
+  cheat: EthCheatCodes,
+  dumpClient: { request: EIP1193RequestFn },
+  opts: { hardfork: string; stateDir: string; startOpts?: Parameters<typeof startAnvil>[0] },
+): Promise<{ anvil: Anvil; forkBlock: { number: bigint; timestamp: bigint } }> {
+  const blockTimeS = await cheat.getIntervalMining();
+  if (!blockTimeS) {
+    throw new Error('restartAnvilOnHardfork needs an anvil in interval mining');
+  }
+  await cheat.setIntervalMining(0, { silent: true });
+  const tip = await cheat.publicClient.getBlock({ blockTag: 'latest' });
+  const statePath = join(opts.stateDir, `anvil-state-${tip.number}.json`);
+  await dumpAnvilStateWithHistory(dumpClient, statePath);
+  await anvil.stop();
+
+  const restarted = await startAnvil({
+    ...opts.startOpts,
+    port: anvil.port,
+    hardfork: opts.hardfork,
+    loadState: statePath,
+    l1BlockTime: blockTimeS,
+  });
+
+  const blockTime = BigInt(blockTimeS);
+  const nowS = BigInt(Math.ceil(cheat.dateProvider.now() / 1000));
+  const slotsSinceTip = nowS > tip.timestamp ? (nowS - tip.timestamp + blockTime - 1n) / blockTime : 1n;
+  await cheat.warp(tip.timestamp + blockTime * slotsSinceTip, { silent: true, resetBlockInterval: true });
+
+  const forkBlock = await cheat.publicClient.getBlock({ blockNumber: tip.number + 1n });
+  return { anvil: restarted.anvil, forkBlock: { number: forkBlock.number, timestamp: forkBlock.timestamp } };
+}

package/src/test/eth_cheat_codes.ts

@@ -3,8 +3,10 @@ import { keccak256 } from '@aztec-labs/foundation/crypto/keccak';
 import { EthAddress } from '@aztec-labs/foundation/eth-address';
 import { jsonStringify } from '@aztec-labs/foundation/json-rpc';
 import { createLogger } from '@aztec-labs/foundation/log';
+import { Semaphore } from '@aztec-labs/foundation/queue';
 import { pluralize } from '@aztec-labs/foundation/string';
 import type { DateProvider, TestDateProvider } from '@aztec-labs/foundation/timer';
+import { Buffer } from 'buffer';
 import {
   type Chain,
   type Hex,
@@ -19,6 +21,66 @@ import { foundry } from 'viem/chains';
 
 import type { ViemPublicClient } from '../types.js';
 
+/** Interval mining that a finished pause hands back to anvil on the next tick of the block grid. */
+type PendingResume = { interval: number; timer: ReturnType<typeof setTimeout> };
+
+/**
+ * Mining state of the test anvil, shared by every {@link EthCheatCodes} instance in the process: e2e builds several over
+ * one anvil (the fixture's, `CheatCodes.eth`, each `RollupCheatCodes`), and a pause or pending resume started by one
+ * must be visible to the others. Assumes every mining-mode cheat code in the process targets one anvil: other anvils may
+ * be started and stopped alongside it, but not paused or switched between mining modes.
+ */
+const anvilMining: {
+  /** Serializes changes to anvil's mining mode against the pending resume. Never held while a caller's code runs. */
+  lock: Semaphore;
+  /** Ports of the anvil the latest pause targeted, which the pause state and any pending resume belong to. */
+  ownerPorts?: string[];
+  /**
+   * Mining mode captured by the pause in progress, restored when it ends. `nextTimestamp` is the next block's timestamp
+   * a caller chose during the pause, which a resume on the grid would overwrite if no block has used it yet.
+   */
+  paused?: { interval: number | null; automine: boolean; nextTimestamp?: number };
+  pendingResume?: PendingResume;
+  /** Bumped on reset, so a resume being scheduled across a reset does not arm a timer for the next anvil. */
+  generation: number;
+} = { lock: new Semaphore(1), generation: 0 };
+
+/** Stops a pending resume and returns the interval it would have restored. */
+function takePendingResume(): number | undefined {
+  const pending = anvilMining.pendingResume;
+  if (!pending) {
+    return undefined;
+  }
+  clearTimeout(pending.timer);
+  anvilMining.pendingResume = undefined;
+  return pending.interval;
+}
+
+/**
+ * Cancels any pending interval-mining resume and forgets the pause state, if they belong to the anvil listening on
+ * `port`. Called when that anvil is stopped, so no timer outlives it and the next anvil starts clean. Stopping any other
+ * anvil, such as a throwaway one a test starts next to its main one, leaves the state alone.
+ */
+export function resetAnvilMiningState(port: number): void {
+  // The owner is kept, so the reset on the anvil's close still clears a timer armed while it was shutting down.
+  if (!anvilMining.ownerPorts?.includes(String(port))) {
+    return;
+  }
+  takePendingResume();
+  anvilMining.paused = undefined;
+  anvilMining.generation++;
+}
+
+/**
+ * A tick missed by at most this long, because a pause ended or the resume timer fired that much after it, is still
+ * mined straight away with its grid timestamp: the block lands up to this late rather than leaving a gap in the chain.
+ * A tick missed by more is skipped, like a missed L1 slot, and mining resumes on the next one.
+ */
+const OVERDUE_TICK_GRACE_MS = 1000;
+
+/** A grid block mined at most this long after its tick restarts anvil's countdown from it; a later one does not. */
+const ON_TIME_TOLERANCE_MS = 100;
+
 /**
  * A class that provides utility functions for interacting with ethereum (L1).
  */
@@ -118,7 +180,7 @@ export class EthCheatCodes {
    * @param numberOfBlocks - The number of blocks to mine
    */
   public async mine(numberOfBlocks: number | bigint = 1): Promise<void> {
-    await this.doMine(Number(numberOfBlocks));
+    await this.withMiningLock(() => this.doMine(Number(numberOfBlocks)));
     this.logger.warn(`Mined ${numberOfBlocks} L1 blocks`);
   }
 
@@ -134,9 +196,13 @@ export class EthCheatCodes {
    * Mines a single block with evm_mine
    */
   public async evmMine(): Promise<void> {
+    await this.withMiningLock(() => this.doEvmMine());
+    this.logger.warn(`Mined 1 L1 block with evm_mine`);
+  }
+
+  private async doEvmMine(): Promise<void> {
     try {
       await this.doRpcCall('evm_mine', []);
-      this.logger.warn(`Mined 1 L1 block with evm_mine`);
     } catch (err) {
       throw new Error(`Error mining: ${err}`);
     }
@@ -188,30 +254,44 @@ export class EthCheatCodes {
   }
 
   /**
-   * Get interval mining if set.
-   * @param seconds - The interval to use between blocks
+   * Get interval mining if set. A pending resume left by {@link execWithPausedAnvil} counts as set, although anvil
+   * itself reports interval mining as off until the resume fires.
    */
-  public getIntervalMining(): Promise<number | null> {
+  public async getIntervalMining(): Promise<number | null> {
+    return await this.withMiningLock(
+      async () => anvilMining.pendingResume?.interval ?? (await this.doGetIntervalMining()),
+    );
+  }
+
+  private async doGetIntervalMining(): Promise<number | null> {
     try {
-      return this.doRpcCall('anvil_getIntervalMining', []);
+      return await this.doRpcCall('anvil_getIntervalMining', []);
     } catch (err) {
       throw new Error(`Error getting interval mining: ${err}`);
     }
   }
 
   /**
-   * Enable interval mining at the given interval (block time)
+   * Enable interval mining at the given interval (block time). Replaces any pending resume left by
+   * {@link execWithPausedAnvil}.
    * @param seconds - The interval to use between blocks
    */
   public async setIntervalMining(seconds: number, opts: { silent?: boolean } = {}): Promise<void> {
+    await this.withMiningLock(async () => {
+      takePendingResume();
+      await this.doSetIntervalMining(seconds);
+    });
+    if (!opts.silent) {
+      this.logger.warn(`Set L1 interval mining to ${seconds} seconds`);
+    }
+  }
+
+  private async doSetIntervalMining(seconds: number): Promise<void> {
     try {
       await this.rpcCall('anvil_setIntervalMining', [seconds]);
     } catch (err) {
       throw new Error(`Error setting interval mining: ${err}`);
     }
-    if (!opts.silent) {
-      this.logger.warn(`Set L1 interval mining to ${seconds} seconds`);
-    }
   }
 
   /**
@@ -222,11 +302,14 @@ export class EthCheatCodes {
       throw new Error(`Interval mining requires a positive interval, got ${seconds}`);
     }
 
-    await this.setAutomine(false);
-    await this.setIntervalMining(0, { silent: true });
-    await this.evmMine();
-    await this.syncDateProvider();
-    await this.setIntervalMining(seconds);
+    await this.withMiningLock(async () => {
+      takePendingResume();
+      await this.doSetAutomine(false);
+      await this.doSetIntervalMining(0);
+      await this.doEvmMine();
+      await this.syncDateProvider();
+      await this.doSetIntervalMining(seconds);
+    });
     this.logger.warn(`Started L1 interval mining at ${seconds} seconds from a fresh block`);
   }
 
@@ -235,14 +318,18 @@ export class EthCheatCodes {
    * @param automine - The automine status to set
    */
   public async setAutomine(automine: boolean, opts: { silent?: boolean } = {}): Promise<void> {
+    await this.withMiningLock(() => this.doSetAutomine(automine));
+    if (!opts.silent) {
+      this.logger.warn(`Set L1 automine to ${automine}`);
+    }
+  }
+
+  private async doSetAutomine(automine: boolean): Promise<void> {
     try {
       await this.rpcCall('anvil_setAutomine', [automine]);
     } catch (err) {
       throw new Error(`Error setting automine: ${err}`);
     }
-    if (!opts.silent) {
-      this.logger.warn(`Set L1 automine to ${automine}`);
-    }
   }
 
   /**
@@ -259,17 +346,27 @@ export class EthCheatCodes {
   }
 
   /**
-   * Set the next block timestamp
+   * Set the next block timestamp. A resume on the block grid after {@link execWithPausedAnvil} would overwrite it, so
+   * interval mining is instead restarted straight away: now if a resume is pending, or when the current pause ends if
+   * no block mined during the pause has used the timestamp.
    * @param timestamp - The timestamp to set the next block to
    */
   public async setNextBlockTimestamp(timestamp: number | Date): Promise<void> {
-    try {
-      await this.rpcCall('evm_setNextBlockTimestamp', [
-        timestamp instanceof Date ? Math.floor(timestamp.getTime() / 1000) : timestamp,
-      ]);
-    } catch (err: any) {
-      throw new Error(`Error setting next block timestamp: ${err.message}`);
-    }
+    const seconds = timestamp instanceof Date ? Math.floor(timestamp.getTime() / 1000) : timestamp;
+    await this.withMiningLock(async () => {
+      const pendingInterval = takePendingResume();
+      if (pendingInterval !== undefined) {
+        await this.doSetIntervalMining(pendingInterval);
+      }
+      if (anvilMining.paused) {
+        anvilMining.paused.nextTimestamp = seconds;
+      }
+      try {
+        await this.rpcCall('evm_setNextBlockTimestamp', [seconds]);
+      } catch (err: any) {
+        throw new Error(`Error setting next block timestamp: ${err.message}`);
+      }
+    });
     this.logger.warn(`Set L1 next block timestamp to ${timestamp}`);
   }
 
@@ -283,31 +380,34 @@ export class EthCheatCodes {
     timestamp: number | bigint,
     opts: { silent?: boolean; resetBlockInterval?: boolean } = {},
   ): Promise<void> {
-    let blockInterval: number | null = null;
-    try {
-      // Load current block interval and disable it
-      if (opts.resetBlockInterval) {
-        blockInterval = await this.getIntervalMining();
-        if (blockInterval !== null) {
-          await this.setIntervalMining(0, { silent: true });
+    await this.withMiningLock(async () => {
+      let blockInterval: number | null = null;
+      try {
+        // Load current block interval and disable it. A pending resume would put mining back on the grid from
+        // before the warp, so take it over: the warp re-phases the grid onto its own timestamp.
+        if (opts.resetBlockInterval) {
+          blockInterval = takePendingResume() ?? (await this.doGetIntervalMining());
+          if (blockInterval !== null) {
+            await this.doSetIntervalMining(0);
+          }
+        }
+        // Set the timestamp of the next block to be mined
+        await this.rpcCall('evm_setNextBlockTimestamp', [Number(timestamp)]);
+        // And mine a block so the timestamp goes into effect now
+        await this.doMine();
+        // Update the injected date provider so it follows L1 time
+        if ('setTime' in this.dateProvider) {
+          this.dateProvider.setTime(Number(timestamp) * 1000);
+        }
+      } catch (err) {
+        throw new Error(`Error warping: ${err}`);
+      } finally {
+        // Restore interval mining so the next block is mined in `blockInterval` seconds from this one
+        if (opts.resetBlockInterval && blockInterval !== null && blockInterval > 0) {
+          await this.doSetIntervalMining(blockInterval);
         }
       }
-      // Set the timestamp of the next block to be mined
-      await this.rpcCall('evm_setNextBlockTimestamp', [Number(timestamp)]);
-      // And mine a block so the timestamp goes into effect now
-      await this.doMine();
-      // Update the injected date provider so it follows L1 time
-      if ('setTime' in this.dateProvider) {
-        this.dateProvider.setTime(Number(timestamp) * 1000);
-      }
-    } catch (err) {
-      throw new Error(`Error warping: ${err}`);
-    } finally {
-      // Restore interval mining so the next block is mined in `blockInterval` seconds from this one
-      if (opts.resetBlockInterval && blockInterval !== null && blockInterval > 0) {
-        await this.setIntervalMining(blockInterval, { silent: true });
-      }
-    }
+    });
     if (!opts.silent) {
       this.logger.warn(`Warped L1 timestamp to ${timestamp}`);
     }
@@ -483,17 +583,19 @@ export class EthCheatCodes {
   ): Promise<void> {
     this.logger.verbose(`Preparing L1 reorg with depth ${depth}`);
     try {
-      await this.rpcCall('anvil_reorg', [
-        depth,
-        newBlocks.flatMap((txs, index) =>
-          txs.map(tx => [
-            typeof tx === 'string'
-              ? tx
-              : { value: 0, ...tx, ...(tx.gas === undefined ? {} : { gas: numberToHex(tx.gas) }) },
-            index,
-          ]),
-        ),
-      ]);
+      await this.withMiningLock(() =>
+        this.rpcCall('anvil_reorg', [
+          depth,
+          newBlocks.flatMap((txs, index) =>
+            txs.map(tx => [
+              typeof tx === 'string'
+                ? tx
+                : { value: 0, ...tx, ...(tx.gas === undefined ? {} : { gas: numberToHex(tx.gas) }) },
+              index,
+            ]),
+          ),
+        ]),
+      );
     } catch (err) {
       throw new Error(`Error reorging: ${err}`);
     }
@@ -576,43 +678,166 @@ export class EthCheatCodes {
     await this.doRpcCall('anvil_setBlockGasLimit', [toHex(gasLimit)]);
   }
 
+  /**
+   * Runs `fn` with automine and interval mining off, so no block is mined while it runs. Called while another pause is
+   * in progress, it just runs `fn` and leaves the mining mode to that pause.
+   *
+   * Automine comes back straight away. Interval mining comes back in the background, on the grid the chain was
+   * already on (see {@link scheduleResume}), so the caller never waits for an L1 tick.
+   */
   public async execWithPausedAnvil<T>(fn: () => Promise<T>): Promise<T> {
-    const [blockInterval, wasAutoMining] = await Promise.all([this.getIntervalMining(), this.isAutoMining()]);
-    try {
-      if (blockInterval !== null) {
-        await this.setIntervalMining(0, { silent: true });
+    const ownsPause = await this.withMiningLock(async () => {
+      if (anvilMining.paused) {
+        return false;
       }
+      await this.pauseMining();
+      return true;
+    });
+    if (!ownsPause) {
+      return await fn();
+    }
 
-      if (wasAutoMining) {
-        await this.setAutomine(false, { silent: true });
-      }
+    try {
+      return await fn();
+    } finally {
+      await this.withMiningLock(() => this.restoreMining());
+    }
+  }
+
+  public async syncDateProvider() {
+    const timestamp = await this.lastBlockTimestamp();
+    if ('setTime' in this.dateProvider) {
+      this.dateProvider.setTime(timestamp * 1000);
+    }
+  }
 
+  private async withMiningLock<T>(fn: () => Promise<T>): Promise<T> {
+    await anvilMining.lock.acquire();
+    try {
       return await fn();
     } finally {
+      anvilMining.lock.release();
+    }
+  }
+
+  private async pauseMining(): Promise<void> {
+    // A resume still pending from an earlier pause is taken over: anvil reports interval mining as off meanwhile.
+    const interval = takePendingResume() ?? (await this.doGetIntervalMining());
+    const paused = { interval, automine: await this.isAutoMining() };
+    anvilMining.paused = paused;
+    anvilMining.ownerPorts = this.rpcUrls.map(url => new URL(url).port);
+    try {
+      if (interval !== null) {
+        await this.doSetIntervalMining(0);
+      }
+      if (paused.automine) {
+        await this.doSetAutomine(false);
+      }
+    } catch (err) {
+      await this.restoreMining();
+      throw err;
+    }
+  }
+
+  private async restoreMining(): Promise<void> {
+    const saved = anvilMining.paused;
+    anvilMining.paused = undefined;
+    if (saved?.automine) {
       try {
-        // restore automine if necessary
-        if (wasAutoMining) {
-          await this.setAutomine(true, { silent: true });
-        }
+        await this.doSetAutomine(true);
       } catch (err) {
         this.logger.warn(`Failed to reenable automining: ${err}`);
       }
-
+    }
+    if (saved?.interval) {
       try {
-        // restore automine if necessary
-        if (blockInterval !== null) {
-          await this.setIntervalMining(blockInterval, { silent: true });
-        }
+        await this.scheduleResume(saved.interval, saved.nextTimestamp);
       } catch (err) {
-        this.logger.warn(`Failed to reenable interval mining: ${err}`);
+        this.logger.warn(`Failed to schedule interval mining on the block grid, restarting it now: ${err}`);
+        try {
+          await this.doSetIntervalMining(saved.interval);
+        } catch (err) {
+          this.logger.warn(`Failed to reenable interval mining: ${err}`);
+        }
       }
     }
   }
 
-  public async syncDateProvider() {
-    const timestamp = await this.lastBlockTimestamp();
-    if ('setTime' in this.dateProvider) {
-      this.dateProvider.setTime(timestamp * 1000);
+  /**
+   * Re-enables interval mining so the next block lands on the grid the chain is already on: the first
+   * `latest + k * interval` tick the node clock has not yet passed. Anvil restarts its countdown from zero on
+   * `anvil_setIntervalMining`, so re-enabling it right after a pause would mine the next block late while still
+   * stamping it `latest + interval`, leaving L1 time behind the node clock for good. Instead mining stays off until
+   * that tick, when a background timer mines the tick's block and restarts the countdown from it.
+   *
+   * A tick the pause ran past by up to {@link OVERDUE_TICK_GRACE_MS} is mined straight away; one missed by more is
+   * skipped, so the lag stays bounded, at the cost of a gap in the chain like a missed L1 slot. Must be called holding
+   * the mining lock.
+   *
+   * @param nextTimestamp - A next-block timestamp a caller set during the pause. Unless a block has already used it, it
+   * is kept: interval mining restarts straight away instead, so the resume does not overwrite it.
+   */
+  private async scheduleResume(interval: number, nextTimestamp?: number): Promise<void> {
+    const generation = anvilMining.generation;
+    const latest = await this.lastBlockTimestamp();
+    if (anvilMining.generation !== generation) {
+      return;
+    }
+    if (nextTimestamp !== undefined && latest < nextTimestamp) {
+      await this.doSetIntervalMining(interval);
+      return;
+    }
+    const nowMs = this.dateProvider.now();
+    const ticks = Math.max(1, Math.ceil((nowMs - OVERDUE_TICK_GRACE_MS - latest * 1000) / (interval * 1000)));
+    const tick = latest + ticks * interval;
+    const delayMs = tick * 1000 - nowMs;
+    if (delayMs > interval * 1000) {
+      // The chain is ahead of the node clock (say, a warp the date provider could not follow), so no tick is due
+      // within an interval: restart the countdown now, as anvil would.
+      await this.doSetIntervalMining(interval);
+      return;
+    }
+    const resume: PendingResume = {
+      interval,
+      timer: setTimeout(() => void this.resumeOnGrid(resume, latest, tick), Math.max(0, delayMs)),
+    };
+    anvilMining.pendingResume = resume;
+  }
+
+  private async resumeOnGrid(resume: PendingResume, latest: number, tick: number) {
+    try {
+      await this.withMiningLock(async () => {
+        if (anvilMining.pendingResume !== resume) {
+          return;
+        }
+        anvilMining.pendingResume = undefined;
+        try {
+          const chainMoved = (await this.lastBlockTimestamp()) !== latest;
+          const firedMs = this.dateProvider.now();
+          if (chainMoved || firedMs - tick * 1000 > OVERDUE_TICK_GRACE_MS) {
+            // Blocks were mined or rolled back while mining was off, so the grid may have moved; or the timer ran
+            // late (a busy event loop, a wait on the lock), and mining the old tick now would put L1 behind again.
+            await this.scheduleResume(resume.interval);
+            return;
+          }
+          await this.doRpcCall('evm_setNextBlockTimestamp', [tick]);
+          await this.doEvmMine();
+          if (this.dateProvider.now() - tick * 1000 > ON_TIME_TOLERANCE_MS) {
+            // The tick was mined late, so a countdown restarted now would keep every later block that late too: wait
+            // for the next tick and restart it there instead.
+            await this.scheduleResume(resume.interval);
+            return;
+          }
+        } catch (err) {
+          this.logger.warn(`Failed to mine the L1 block due at ${tick}, restarting interval mining off the grid`, {
+            err: String(err),
+            tick,
+          });
+        }
+        await this.doSetIntervalMining(resume.interval);
+      });
+    } catch (err) {
+      this.logger.error(`Failed to resume L1 interval mining`, err, { interval: resume.interval, tick });
     }
   }
 }