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

package/dest/test/eth_cheat_codes.d.ts

@@ -2,6 +2,12 @@ import { EthAddress } from '@aztec-labs/foundation/eth-address';
 import type { DateProvider, TestDateProvider } from '@aztec-labs/foundation/timer';
 import { type Chain, type Hex, type Transaction } from 'viem';
 import type { ViemPublicClient } from '../types.js';
+/**
+ * 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 declare function resetAnvilMiningState(port: number): void;
 /**
  * A class that provides utility functions for interacting with ethereum (L1).
  */
@@ -80,6 +86,7 @@ export declare class EthCheatCodes {
      * Mines a single block with evm_mine
      */
     evmMine(): Promise<void>;
+    private doEvmMine;
     /**
      * Set the balance of an account
      * @param account - The account to set the balance for
@@ -98,17 +105,20 @@ export declare class EthCheatCodes {
      */
     setNextBlockBaseFeePerGas(baseFee: bigint | number): Promise<void>;
     /**
-     * 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.
      */
     getIntervalMining(): Promise<number | null>;
+    private doGetIntervalMining;
     /**
-     * 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
      */
     setIntervalMining(seconds: number, opts?: {
         silent?: boolean;
     }): Promise<void>;
+    private doSetIntervalMining;
     /**
      * Starts interval mining from a freshly mined block and syncs the date provider to the block timestamp.
      */
@@ -120,13 +130,16 @@ export declare class EthCheatCodes {
     setAutomine(automine: boolean, opts?: {
         silent?: boolean;
     }): Promise<void>;
+    private doSetAutomine;
     /**
      * Drop a transaction from the mempool
      * @param txHash - The transaction hash
      */
     dropTransaction(txHash: Hex): Promise<void>;
     /**
-     * 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
      */
     setNextBlockTimestamp(timestamp: number | Date): Promise<void>;
@@ -253,12 +266,24 @@ export declare class EthCheatCodes {
     getBlockGasLimit(): Promise<bigint>;
     /** Sets the block gas limit applied to subsequently mined L1 blocks. */
     setBlockGasLimit(gasLimit: bigint): Promise<void>;
+    /**
+     * 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.
+     */
     execWithPausedAnvil<T>(fn: () => Promise<T>): Promise<T>;
     syncDateProvider(): Promise<void>;
+    private withMiningLock;
+    private pauseMining;
+    private restoreMining;
+    private scheduleResume;
+    private resumeOnGrid;
 }
 type TxPoolState = 'pending' | 'queued';
 export type TxPoolTransaction = Transaction & {
     poolState: TxPoolState;
 };
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXRoX2NoZWF0X2NvZGVzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdC9ldGhfY2hlYXRfY29kZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBS2hFLE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBRW5GLE9BQU8sRUFDTCxLQUFLLEtBQUssRUFDVixLQUFLLEdBQUcsRUFDUixLQUFLLFdBQVcsRUFNakIsTUFBTSxNQUFNLENBQUM7QUFHZCxPQUFPLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQXFDcEQ7Ozs7R0FJRztBQUNILHdCQUFnQixxQkFBcUIsQ0FBQyxJQUFJLEVBQUUsTUFBTSxHQUFHLElBQUksQ0FReEQ7QUFZRDs7R0FFRztBQUNILHFCQUFhLGFBQWE7SUFHdEI7O09BRUc7SUFDSSxPQUFPLEVBQUUsTUFBTSxFQUFFO0lBQ3hCOztPQUVHO0lBQ0ksWUFBWSxFQUFFLFlBQVksR0FBRyxnQkFBZ0I7SUFDcEQ7O09BRUc7SUFDSSxNQUFNO0lBQ2I7O09BRUc7SUFDSSxLQUFLLEVBQUUsS0FBSztJQWpCckIsU0FBZ0IsWUFBWSxFQUFFLGdCQUFnQixDQUFDO0lBQy9DO0lBQ0U7O09BRUc7SUFDSSxPQUFPLEVBQUUsTUFBTSxFQUFFO0lBQ3hCOztPQUVHO0lBQ0ksWUFBWSxFQUFFLFlBQVksR0FBRyxnQkFBZ0I7SUFDcEQ7O09BRUc7SUFDSSxNQUFNLDhDQUF1QztJQUNwRDs7T0FFRztJQUNJLEtBQUssR0FBRSxLQUFlLEVBTTlCO0lBRU0sT0FBTyxDQUFDLE1BQU0sRUFBRSxNQUFNLEVBQUUsTUFBTSxFQUFFLEdBQUcsRUFBRSxnQkFHM0M7WUFFYSxTQUFTO0lBT3ZCOzs7T0FHRztJQUNVLFlBQVksSUFBSSxPQUFPLENBQUMsT0FBTyxDQUFDLENBUTVDO0lBRUQ7OztPQUdHO0lBQ1UsV0FBVyxJQUFJLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FHMUM7SUFFRDs7O09BR0c7SUFDVSxPQUFPLElBQUksT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUd0QztJQUVEOzs7OztPQUtHO0lBQ1Usa0JBQWtCLElBQUksT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUdqRDtJQUVEOzs7O09BSUc7SUFDVSxrQkFBa0IsSUFBSSxPQUFPLENBQUMsTUFBTSxDQUFDLENBR2pEO0lBRUQ7OztPQUdHO0lBQ1UsSUFBSSxDQUFDLGNBQWMsR0FBRSxNQUFNLEdBQUcsTUFBVSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FHcEU7WUFFYSxNQUFNO0lBUXBCOztPQUVHO0lBQ1UsT0FBTyxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FHcEM7WUFFYSxTQUFTO0lBUXZCOzs7O09BSUc7SUFDVSxVQUFVLENBQUMsT0FBTyxFQUFFLFVBQVUsR0FBRyxHQUFHLEVBQUUsT0FBTyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBT2pGO0lBRVksVUFBVSxDQUFDLE9BQU8sRUFBRSxVQUFVLEdBQUcsR0FBRyxHQUFHLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FHbEU7SUFFRDs7O09BR0c7SUFDVSxnQkFBZ0IsQ0FBQyxRQUFRLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FPN0Q7SUFFRDs7O09BR0c7SUFDVSx5QkFBeUIsQ0FBQyxPQUFPLEVBQUUsTUFBTSxHQUFHLE1BQU0sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBTzlFO0lBRUQ7OztPQUdHO0lBQ1UsaUJBQWlCLElBQUksT0FBTyxDQUFDLE1BQU0sR0FBRyxJQUFJLENBQUMsQ0FJdkQ7WUFFYSxtQkFBbUI7SUFRakM7Ozs7T0FJRztJQUNVLGlCQUFpQixDQUFDLE9BQU8sRUFBRSxNQUFNLEVBQUUsSUFBSSxHQUFFO1FBQUUsTUFBTSxDQUFDLEVBQUUsT0FBTyxDQUFBO0tBQU8sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBUTlGO1lBRWEsbUJBQW1CO0lBUWpDOztPQUVHO0lBQ1UsaUNBQWlDLENBQUMsT0FBTyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBYzdFO0lBRUQ7OztPQUdHO0lBQ1UsV0FBVyxDQUFDLFFBQVEsRUFBRSxPQUFPLEVBQUUsSUFBSSxHQUFFO1FBQUUsTUFBTSxDQUFDLEVBQUUsT0FBTyxDQUFBO0tBQU8sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBSzFGO1lBRWEsYUFBYTtJQVEzQjs7O09BR0c7SUFDVSxlQUFlLENBQUMsTUFBTSxFQUFFLEdBQUcsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBT3ZEO0lBRUQ7Ozs7O09BS0c7SUFDVSxxQkFBcUIsQ0FBQyxTQUFTLEVBQUUsTUFBTSxHQUFHLElBQUksR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBaUIxRTtJQUVEOzs7OztPQUtHO0lBQ1UsSUFBSSxDQUNmLFNBQVMsRUFBRSxNQUFNLEdBQUcsTUFBTSxFQUMxQixJQUFJLEdBQUU7UUFBRSxNQUFNLENBQUMsRUFBRSxPQUFPLENBQUM7UUFBQyxrQkFBa0IsQ0FBQyxFQUFFLE9BQU8sQ0FBQTtLQUFPLEdBQzVELE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FnQ2Y7SUFFRDs7Ozs7T0FLRztJQUNVLElBQUksQ0FBQyxRQUFRLEVBQUUsVUFBVSxFQUFFLElBQUksRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUdyRTtJQUVEOzs7OztPQUtHO0lBQ1UsS0FBSyxDQUNoQixRQUFRLEVBQUUsVUFBVSxFQUNwQixJQUFJLEVBQUUsTUFBTSxFQUNaLEtBQUssRUFBRSxNQUFNLEVBQ2IsSUFBSSxHQUFFO1FBQUUsTUFBTSxDQUFDLEVBQUUsT0FBTyxDQUFBO0tBQU8sR0FDOUIsT0FBTyxDQUFDLElBQUksQ0FBQyxDQVVmO0lBRUQ7Ozs7O09BS0c7SUFDSSxTQUFTLENBQUMsUUFBUSxFQUFFLE1BQU0sRUFBRSxHQUFHLEVBQUUsTUFBTSxHQUFHLE1BQU0sQ0FJdEQ7SUFFRDs7O09BR0c7SUFDVSxrQkFBa0IsQ0FBQyxHQUFHLEVBQUUsVUFBVSxHQUFHLEdBQUcsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBWXBFO0lBRUQ7OztPQUdHO0lBQ1UsaUJBQWlCLENBQUMsR0FBRyxFQUFFLFVBQVUsR0FBRyxHQUFHLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQU9uRTtJQUVEOzs7O09BSUc7SUFDVSxJQUFJLENBQUMsUUFBUSxFQUFFLFVBQVUsRUFBRSxRQUFRLEVBQUUsS0FBSyxNQUFNLEVBQUUsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBTzlFO0lBRUQ7Ozs7T0FJRztJQUNVLFdBQVcsQ0FBQyxRQUFRLEVBQUUsVUFBVSxHQUFHLE9BQU8sQ0FBQyxLQUFLLE1BQU0sRUFBRSxDQUFDLENBRXJFO0lBRUQ7Ozs7T0FJRztJQUNVLGlCQUFpQixDQUFDLE1BQU0sRUFBRSxHQUFHLEdBQUcsT0FBTyxDQUFDLEtBQUssTUFBTSxFQUFFLENBQUMsQ0FFbEU7SUFFRDs7OztPQUlHO0lBQ1UscUJBQXFCLENBQUMsTUFBTSxFQUFFLEdBQUcsR0FBRyxPQUFPLENBQUMsR0FBRyxDQUFDLENBRTVEO0lBRUQ7OztPQUdHO0lBQ0ksS0FBSyxDQUFDLEtBQUssRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUl6QztJQUVEOzs7T0FHRztJQUNJLE9BQU8sQ0FBQyxXQUFXLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FrQmpEO0lBRUQ7Ozs7Ozs7O09BUUc7SUFDVSxvQkFBb0IsQ0FDL0IsS0FBSyxFQUFFLE1BQU0sRUFDYixTQUFTLEdBQUUsQ0FDUCxHQUFHLEdBQ0g7UUFBRSxFQUFFLEVBQUUsVUFBVSxHQUFHLEdBQUcsQ0FBQztRQUFDLEtBQUssQ0FBQyxFQUFFLEdBQUcsQ0FBQztRQUFDLElBQUksQ0FBQyxFQUFFLFVBQVUsR0FBRyxHQUFHLENBQUM7UUFBQyxLQUFLLENBQUMsRUFBRSxNQUFNLEdBQUcsTUFBTSxDQUFDO1FBQUMsR0FBRyxDQUFDLEVBQUUsTUFBTSxDQUFBO0tBQUUsQ0FDeEcsRUFBRSxFQUFPLEdBQ1QsT0FBTyxDQUFDLElBQUksQ0FBQyxDQW9CZjtJQUVNLGdCQUFnQixDQUFDLE1BQU0sRUFBRSxHQUFHLEdBQUcsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUVqRDtJQUVZLGVBQWUsSUFBSSxPQUFPLENBQUM7UUFBRSxPQUFPLEVBQUUsTUFBTSxDQUFDO1FBQUMsTUFBTSxFQUFFLE1BQU0sQ0FBQTtLQUFFLENBQUMsQ0FHM0U7SUFFWSxpQkFBaUIsSUFBSSxPQUFPLENBQUMsaUJBQWlCLEVBQUUsQ0FBQyxDQUc3RDtJQUVEOzs7Ozs7Ozs7Ozs7Ozs7Ozs7T0FrQkc7SUFDVSxjQUFjLENBQUMsVUFBVSxHQUFFLE1BQVUsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBOEJqRTtJQUVELDBEQUEwRDtJQUM3QyxnQkFBZ0IsSUFBSSxPQUFPLENBQUMsTUFBTSxDQUFDLENBRy9DO0lBRUQsd0VBQXdFO0lBQzNELGdCQUFnQixDQUFDLFFBQVEsRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUU3RDtJQUVEOzs7Ozs7T0FNRztJQUNVLG1CQUFtQixDQUFDLENBQUMsRUFBRSxFQUFFLEVBQUUsTUFBTSxPQUFPLENBQUMsQ0FBQyxDQUFDLEdBQUcsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQWlCcEU7SUFFWSxnQkFBZ0Isa0JBSzVCO1lBRWEsY0FBYztZQVNkLFdBQVc7WUFtQlgsYUFBYTtZQXNDYixjQUFjO1lBMkJkLFlBQVk7Q0FvQzNCO0FBRUQsS0FBSyxXQUFXLEdBQUcsU0FBUyxHQUFHLFFBQVEsQ0FBQztBQU94QyxNQUFNLE1BQU0saUJBQWlCLEdBQUcsV0FBVyxHQUFHO0lBQzVDLFNBQVMsRUFBRSxXQUFXLENBQUM7Q0FDeEIsQ0FBQyJ9

package/dest/test/eth_cheat_codes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"eth_cheat_codes.d.ts","sourceRoot":"","sources":["../../src/test/eth_cheat_codes.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"eth_cheat_codes.d.ts","sourceRoot":"","sources":["../../src/test/eth_cheat_codes.ts"],"names":[],"mappings":"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"}

package/dest/test/eth_cheat_codes.js

@@ -2,9 +2,48 @@ import { toBigIntBE, toHex } from '@aztec-labs/foundation/bigint-buffer';
 import { keccak256 } from '@aztec-labs/foundation/crypto/keccak';
 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 { Buffer } from 'buffer';
 import { createPublicClient, fallback, hexToNumber, http, numberToHex } from 'viem';
 import { foundry } from 'viem/chains';
+/**
+ * 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 = {
+    lock: new Semaphore(1),
+    generation: 0
+};
+/** Stops a pending resume and returns the interval it would have restored. */ function takePendingResume() {
+    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) {
+    // 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).
  */ export class EthCheatCodes {
@@ -96,7 +135,7 @@ import { foundry } from 'viem/chains';
    * Advance the chain by a number of blocks
    * @param numberOfBlocks - The number of blocks to mine
    */ async mine(numberOfBlocks = 1) {
-        await this.doMine(Number(numberOfBlocks));
+        await this.withMiningLock(()=>this.doMine(Number(numberOfBlocks)));
         this.logger.warn(`Mined ${numberOfBlocks} L1 blocks`);
     }
     async doMine(numberOfBlocks = 1) {
@@ -111,9 +150,12 @@ import { foundry } from 'viem/chains';
     /**
    * Mines a single block with evm_mine
    */ async evmMine() {
+        await this.withMiningLock(()=>this.doEvmMine());
+        this.logger.warn(`Mined 1 L1 block with evm_mine`);
+    }
+    async doEvmMine() {
         try {
             await this.doRpcCall('evm_mine', []);
-            this.logger.warn(`Mined 1 L1 block with evm_mine`);
         } catch (err) {
             throw new Error(`Error mining: ${err}`);
         }
@@ -167,19 +209,32 @@ import { foundry } from 'viem/chains';
         this.logger.warn(`Set L1 next block base fee per gas to ${baseFee}`);
     }
     /**
-   * Get interval mining if set.
-   * @param seconds - The interval to use between blocks
-   */ getIntervalMining() {
+   * 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.
+   */ async getIntervalMining() {
+        return await this.withMiningLock(async ()=>anvilMining.pendingResume?.interval ?? await this.doGetIntervalMining());
+    }
+    async doGetIntervalMining() {
         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
    */ async setIntervalMining(seconds, opts = {}) {
+        await this.withMiningLock(async ()=>{
+            takePendingResume();
+            await this.doSetIntervalMining(seconds);
+        });
+        if (!opts.silent) {
+            this.logger.warn(`Set L1 interval mining to ${seconds} seconds`);
+        }
+    }
+    async doSetIntervalMining(seconds) {
         try {
             await this.rpcCall('anvil_setIntervalMining', [
                 seconds
@@ -187,9 +242,6 @@ import { foundry } from 'viem/chains';
         } catch (err) {
             throw new Error(`Error setting interval mining: ${err}`);
         }
-        if (!opts.silent) {
-            this.logger.warn(`Set L1 interval mining to ${seconds} seconds`);
-        }
     }
     /**
    * Starts interval mining from a freshly mined block and syncs the date provider to the block timestamp.
@@ -197,19 +249,26 @@ import { foundry } from 'viem/chains';
         if (seconds <= 0) {
             throw new Error(`Interval mining requires a positive interval, got ${seconds}`);
         }
-        await this.setAutomine(false);
-        await this.setIntervalMining(0, {
-            silent: true
+        await this.withMiningLock(async ()=>{
+            takePendingResume();
+            await this.doSetAutomine(false);
+            await this.doSetIntervalMining(0);
+            await this.doEvmMine();
+            await this.syncDateProvider();
+            await this.doSetIntervalMining(seconds);
         });
-        await this.evmMine();
-        await this.syncDateProvider();
-        await this.setIntervalMining(seconds);
         this.logger.warn(`Started L1 interval mining at ${seconds} seconds from a fresh block`);
     }
     /**
    * Set the automine status of the underlying anvil chain
    * @param automine - The automine status to set
    */ async setAutomine(automine, opts = {}) {
+        await this.withMiningLock(()=>this.doSetAutomine(automine));
+        if (!opts.silent) {
+            this.logger.warn(`Set L1 automine to ${automine}`);
+        }
+    }
+    async doSetAutomine(automine) {
         try {
             await this.rpcCall('anvil_setAutomine', [
                 automine
@@ -217,9 +276,6 @@ import { foundry } from 'viem/chains';
         } catch (err) {
             throw new Error(`Error setting automine: ${err}`);
         }
-        if (!opts.silent) {
-            this.logger.warn(`Set L1 automine to ${automine}`);
-        }
     }
     /**
    * Drop a transaction from the mempool
@@ -235,16 +291,28 @@ import { foundry } from 'viem/chains';
         this.logger.warn(`Dropped transaction ${txHash}`);
     }
     /**
-   * 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
    */ async setNextBlockTimestamp(timestamp) {
-        try {
-            await this.rpcCall('evm_setNextBlockTimestamp', [
-                timestamp instanceof Date ? Math.floor(timestamp.getTime() / 1000) : timestamp
-            ]);
-        } catch (err) {
-            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) {
+                throw new Error(`Error setting next block timestamp: ${err.message}`);
+            }
+        });
         this.logger.warn(`Set L1 next block timestamp to ${timestamp}`);
     }
     /**
@@ -253,37 +321,36 @@ import { foundry } from 'viem/chains';
    * Always updates the injected date provider to follow L1 time.
    * @param timestamp - The timestamp to set the next block to
    */ async warp(timestamp, opts = {}) {
-        let blockInterval = 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 = 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}`);
         }
@@ -445,19 +512,19 @@ import { foundry } from 'viem/chains';
    */ async reorgWithReplacement(depth, newBlocks = []) {
         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}`);
         }
@@ -549,50 +616,165 @@ import { foundry } from 'viem/chains';
             toHex(gasLimit)
         ]);
     }
-    async execWithPausedAnvil(fn) {
-        const [blockInterval, wasAutoMining] = await Promise.all([
-            this.getIntervalMining(),
-            this.isAutoMining()
-        ]);
-        try {
-            if (blockInterval !== null) {
-                await this.setIntervalMining(0, {
-                    silent: true
-                });
-            }
-            if (wasAutoMining) {
-                await this.setAutomine(false, {
-                    silent: true
-                });
+    /**
+   * 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.
+   */ async execWithPausedAnvil(fn) {
+        const ownsPause = await this.withMiningLock(async ()=>{
+            if (anvilMining.paused) {
+                return false;
             }
+            await this.pauseMining();
+            return true;
+        });
+        if (!ownsPause) {
+            return await fn();
+        }
+        try {
             return await fn();
         } finally{
+            await this.withMiningLock(()=>this.restoreMining());
+        }
+    }
+    async syncDateProvider() {
+        const timestamp = await this.lastBlockTimestamp();
+        if ('setTime' in this.dateProvider) {
+            this.dateProvider.setTime(timestamp * 1000);
+        }
+    }
+    async withMiningLock(fn) {
+        await anvilMining.lock.acquire();
+        try {
+            return await fn();
+        } finally{
+            anvilMining.lock.release();
+        }
+    }
+    async pauseMining() {
+        // 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;
+        }
+    }
+    async restoreMining() {
+        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}`);
+                }
             }
         }
     }
-    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.
+   */ async scheduleResume(interval, nextTimestamp) {
+        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 = {
+            interval,
+            timer: setTimeout(()=>void this.resumeOnGrid(resume, latest, tick), Math.max(0, delayMs))
+        };
+        anvilMining.pendingResume = resume;
+    }
+    async resumeOnGrid(resume, latest, tick) {
+        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
+            });
         }
     }
 }

package/dest/test/index.d.ts

@@ -1,8 +1,10 @@
+export * from './anvil_hardfork.js';
 export * from './blob_kzg_warmup.js';
 export * from './eth_cheat_codes.js';
 export * from './eth_cheat_codes_with_state.js';
+export * from './l1_hardfork.js';
 export * from './start_anvil.js';
 export * from './upgrade_utils.js';
 export * from './chain_monitor.js';
 export * from './rollup_cheat_codes.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMseUJBQXlCLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsaUNBQWlDLENBQUM7QUFDaEQsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHlCQUF5QixDQUFDIn0=

package/dest/test/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iCAAiC,CAAC;AAChD,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iCAAiC,CAAC;AAChD,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC"}

package/dest/test/index.js

@@ -1,6 +1,8 @@
+export * from './anvil_hardfork.js';
 export * from './blob_kzg_warmup.js';
 export * from './eth_cheat_codes.js';
 export * from './eth_cheat_codes_with_state.js';
+export * from './l1_hardfork.js';
 export * from './start_anvil.js';
 export * from './upgrade_utils.js';
 export * from './chain_monitor.js';