@aztec/ethereum 1.2.1 → 2.0.0-nightly.20250813

package/src/index.ts

@@ -1,7 +1,6 @@
 export * from './constants.js';
 export * from './deploy_l1_contracts.js';
 export * from './chain.js';
-export * from './eth_cheat_codes.js';
 export * from './l1_tx_utils.js';
 export * from './l1_contract_addresses.js';
 export * from './l1_reader.js';
@@ -13,3 +12,4 @@ export * from './queries.js';
 export * from './client.js';
 export * from './account.js';
 export * from './l1_types.js';
+export * from './l1_artifacts.js';

package/src/l1_artifacts.ts

@@ -0,0 +1,216 @@
+import {
+  CoinIssuerAbi,
+  CoinIssuerBytecode,
+  ExtRollupLib2Abi,
+  ExtRollupLib2Bytecode,
+  ExtRollupLib3Abi,
+  ExtRollupLib3Bytecode,
+  ExtRollupLibAbi,
+  ExtRollupLibBytecode,
+  FeeAssetHandlerAbi,
+  FeeAssetHandlerBytecode,
+  FeeJuicePortalAbi,
+  FeeJuicePortalBytecode,
+  GSEAbi,
+  GSEBytecode,
+  GovernanceAbi,
+  GovernanceBytecode,
+  GovernanceProposerAbi,
+  GovernanceProposerBytecode,
+  HonkVerifierAbi,
+  HonkVerifierBytecode,
+  InboxAbi,
+  InboxBytecode,
+  MockVerifierAbi,
+  MockVerifierBytecode,
+  MockZKPassportVerifierAbi,
+  MockZKPassportVerifierBytecode,
+  MultiAdderAbi,
+  MultiAdderBytecode,
+  OutboxAbi,
+  OutboxBytecode,
+  RegisterNewRollupVersionPayloadAbi,
+  RegisterNewRollupVersionPayloadBytecode,
+  RegistryAbi,
+  RegistryBytecode,
+  RewardDistributorAbi,
+  RewardDistributorBytecode,
+  RollupAbi,
+  RollupBytecode,
+  RollupLinkReferences,
+  SlashFactoryAbi,
+  SlashFactoryBytecode,
+  SlasherAbi,
+  SlasherBytecode,
+  StakingAssetHandlerAbi,
+  StakingAssetHandlerBytecode,
+  TestERC20Abi,
+  TestERC20Bytecode,
+  ValidatorSelectionLibAbi,
+  ValidatorSelectionLibBytecode,
+} from '@aztec/l1-artifacts';
+
+import type { Hex } from 'viem';
+
+export const RegistryArtifact = {
+  name: 'Registry',
+  contractAbi: RegistryAbi,
+  contractBytecode: RegistryBytecode as Hex,
+};
+
+export const InboxArtifact = {
+  name: 'Inbox',
+  contractAbi: InboxAbi,
+  contractBytecode: InboxBytecode as Hex,
+};
+
+export const OutboxArtifact = {
+  name: 'Outbox',
+  contractAbi: OutboxAbi,
+  contractBytecode: OutboxBytecode as Hex,
+};
+
+export const RollupArtifact = {
+  name: 'Rollup',
+  contractAbi: RollupAbi,
+  contractBytecode: RollupBytecode as Hex,
+  libraries: {
+    linkReferences: RollupLinkReferences,
+    libraryCode: {
+      ValidatorSelectionLib: {
+        name: 'ValidatorSelectionLib',
+        contractAbi: ValidatorSelectionLibAbi,
+        contractBytecode: ValidatorSelectionLibBytecode as Hex,
+      },
+      ExtRollupLib: {
+        name: 'ExtRollupLib',
+        contractAbi: ExtRollupLibAbi,
+        contractBytecode: ExtRollupLibBytecode as Hex,
+      },
+      ExtRollupLib2: {
+        name: 'ExtRollupLib2',
+        contractAbi: ExtRollupLib2Abi,
+        contractBytecode: ExtRollupLib2Bytecode as Hex,
+      },
+      ExtRollupLib3: {
+        name: 'ExtRollupLib3',
+        contractAbi: ExtRollupLib3Abi,
+        contractBytecode: ExtRollupLib3Bytecode as Hex,
+      },
+    },
+  },
+};
+
+export const StakingAssetArtifact = {
+  name: 'StakingAsset',
+  contractAbi: TestERC20Abi,
+  contractBytecode: TestERC20Bytecode as Hex,
+};
+
+export const FeeAssetArtifact = {
+  name: 'FeeAsset',
+  contractAbi: TestERC20Abi,
+  contractBytecode: TestERC20Bytecode as Hex,
+};
+
+export const FeeJuicePortalArtifact = {
+  name: 'FeeJuicePortal',
+  contractAbi: FeeJuicePortalAbi,
+  contractBytecode: FeeJuicePortalBytecode as Hex,
+};
+
+export const RewardDistributorArtifact = {
+  name: 'RewardDistributor',
+  contractAbi: RewardDistributorAbi,
+  contractBytecode: RewardDistributorBytecode as Hex,
+};
+
+export const CoinIssuerArtifact = {
+  name: 'CoinIssuer',
+  contractAbi: CoinIssuerAbi,
+  contractBytecode: CoinIssuerBytecode as Hex,
+};
+
+export const GovernanceProposerArtifact = {
+  name: 'GovernanceProposer',
+  contractAbi: GovernanceProposerAbi,
+  contractBytecode: GovernanceProposerBytecode as Hex,
+};
+
+export const GovernanceArtifact = {
+  name: 'Governance',
+  contractAbi: GovernanceAbi,
+  contractBytecode: GovernanceBytecode as Hex,
+};
+
+export const SlasherArtifact = {
+  name: 'Slasher',
+  contractAbi: SlasherAbi,
+  contractBytecode: SlasherBytecode as Hex,
+};
+
+export const SlashFactoryArtifact = {
+  name: 'SlashFactory',
+  contractAbi: SlashFactoryAbi,
+  contractBytecode: SlashFactoryBytecode as Hex,
+};
+
+export const RegisterNewRollupVersionPayloadArtifact = {
+  name: 'RegisterNewRollupVersionPayload',
+  contractAbi: RegisterNewRollupVersionPayloadAbi,
+  contractBytecode: RegisterNewRollupVersionPayloadBytecode as Hex,
+};
+
+export const FeeAssetHandlerArtifact = {
+  name: 'FeeAssetHandler',
+  contractAbi: FeeAssetHandlerAbi,
+  contractBytecode: FeeAssetHandlerBytecode as Hex,
+};
+
+export const StakingAssetHandlerArtifact = {
+  name: 'StakingAssetHandler',
+  contractAbi: StakingAssetHandlerAbi,
+  contractBytecode: StakingAssetHandlerBytecode as Hex,
+};
+
+export const MultiAdderArtifact = {
+  name: 'MultiAdder',
+  contractAbi: MultiAdderAbi,
+  contractBytecode: MultiAdderBytecode as Hex,
+};
+
+export const GSEArtifact = {
+  name: 'GSE',
+  contractAbi: GSEAbi,
+  contractBytecode: GSEBytecode as Hex,
+};
+
+// Verifier artifacts
+export const HonkVerifierArtifact = {
+  name: 'HonkVerifier',
+  contractAbi: HonkVerifierAbi,
+  contractBytecode: HonkVerifierBytecode as Hex,
+};
+
+export const MockVerifierArtifact = {
+  name: 'MockVerifier',
+  contractAbi: MockVerifierAbi,
+  contractBytecode: MockVerifierBytecode as Hex,
+};
+
+export const MockZkPassportVerifierArtifact = {
+  name: 'MockZkPassportVerifier',
+  contractAbi: MockZKPassportVerifierAbi,
+  contractBytecode: MockZKPassportVerifierBytecode as Hex,
+};
+
+// Re-export the verifier artifacts for backwards compatibility
+export const l1ArtifactsVerifiers = {
+  honkVerifier: HonkVerifierArtifact,
+};
+
+// Re-export the mock verifiers for backwards compatibility
+export const mockVerifiers = {
+  mockVerifier: MockVerifierArtifact,
+  mockZkPassportVerifier: MockZkPassportVerifierArtifact,
+};

package/src/l1_tx_utils.ts

@@ -10,6 +10,7 @@ import {
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { makeBackoff, retry } from '@aztec/foundation/retry';
 import { sleep } from '@aztec/foundation/sleep';
+import { DateProvider } from '@aztec/foundation/timer';
 import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
 
 import pickBy from 'lodash.pickby';
@@ -215,6 +216,7 @@ export class ReadOnlyL1TxUtils {
   constructor(
     public client: ViemClient,
     protected logger: Logger = createLogger('ReadOnlyL1TxUtils'),
+    public readonly dateProvider: DateProvider,
     config?: Partial<L1TxUtilsConfig>,
     protected debugMaxGasLimit: boolean = false,
   ) {
@@ -501,20 +503,15 @@ export class ReadOnlyL1TxUtils {
         ],
       });
 
-      this.logger?.debug(`L1 gas used in simulation: ${result[0].calls[0].gasUsed}`, {
-        result,
-      });
       if (result[0].calls[0].status === 'failure') {
-        this.logger?.error('L1 transaction Simulation failed', {
-          error: result[0].calls[0].error,
-        });
-        const decodedError = decodeErrorResult({
-          abi,
-          data: result[0].calls[0].data,
-        });
+        this.logger?.error('L1 transaction simulation failed', result[0].calls[0].error);
+        const decodedError = decodeErrorResult({ abi, data: result[0].calls[0].data });
 
-        throw new Error(`L1 transaction simulation failed with error: ${decodedError.errorName}`);
+        throw new Error(
+          `L1 transaction simulation failed with error ${decodedError.errorName}(${decodedError.args?.join(',')})`,
+        );
       }
+      this.logger?.debug(`L1 transaction simulation succeeded`, { ...result[0].calls[0] });
       return { gasUsed: result[0].gasUsed, result: result[0].calls[0].data as `0x${string}` };
     } catch (err) {
       if (err instanceof MethodNotFoundRpcError || err instanceof MethodNotSupportedRpcError) {
@@ -544,10 +541,11 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
   constructor(
     public override client: ExtendedViemWalletClient,
     protected override logger: Logger = createLogger('L1TxUtils'),
+    dateProvider: DateProvider = new DateProvider(),
     config?: Partial<L1TxUtilsConfig>,
     debugMaxGasLimit: boolean = false,
   ) {
-    super(client, logger, config, debugMaxGasLimit);
+    super(client, logger, dateProvider, config, debugMaxGasLimit);
     if (!isExtendedClient(this.client)) {
       throw new Error('L1TxUtils has to be instantiated with a wallet client.');
     }
@@ -577,8 +575,8 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
     try {
       const gasConfig = { ...this.config, ..._gasConfig };
       const account = this.client.account;
-      let gasLimit: bigint;
 
+      let gasLimit: bigint;
       if (this.debugMaxGasLimit) {
         gasLimit = LARGE_GAS_LIMIT;
       } else if (gasConfig.gasLimit) {
@@ -586,12 +584,11 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
       } else {
         gasLimit = await this.estimateGas(account, request, gasConfig);
       }
-
-      this.logger?.debug('Gas limit', { gasLimit });
+      this.logger?.debug(`Gas limit for request is ${gasLimit}`, { gasLimit, ...request });
 
       const gasPrice = await this.getGasPrice(gasConfig, !!blobInputs);
 
-      if (gasConfig.txTimeoutAt && Date.now() > gasConfig.txTimeoutAt.getTime()) {
+      if (gasConfig.txTimeoutAt && this.dateProvider.now() > gasConfig.txTimeoutAt.getTime()) {
         throw new Error('Transaction timed out before sending');
       }
 
@@ -676,7 +673,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
     const txHashes = new Set<Hex>([initialTxHash]);
     let currentTxHash = initialTxHash;
     let attempts = 0;
-    let lastAttemptSent = Date.now();
+    let lastAttemptSent = this.dateProvider.now();
     let lastGasPrice: GasPrice = {
       maxFeePerGas: tx.maxFeePerGas!,
       maxPriorityFeePerGas: tx.maxPriorityFeePerGas!,
@@ -685,14 +682,26 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
     const initialTxTime = lastAttemptSent;
 
     let txTimedOut = false;
+    let latestBlockTimestamp: bigint | undefined;
+
+    // We check against the latestBlockTimestamp as opposed to the current time to avoid a race condition where
+    // the tx is mined in a block with the same timestamp as txTimeoutAt, but our execution node has not yet processed it,
+    // or the loop here has not yet checked the tx before that timeout.
     const isTimedOut = () =>
-      (gasConfig.txTimeoutAt && Date.now() > gasConfig.txTimeoutAt.getTime()) ||
-      (gasConfig.txTimeoutMs !== undefined && Date.now() - initialTxTime > gasConfig.txTimeoutMs) ||
+      (gasConfig.txTimeoutAt &&
+        latestBlockTimestamp !== undefined &&
+        Number(latestBlockTimestamp) * 1000 >= gasConfig.txTimeoutAt.getTime()) ||
+      (gasConfig.txTimeoutMs !== undefined && this.dateProvider.now() - initialTxTime > gasConfig.txTimeoutMs) ||
       this.interrupted ||
       false;
 
     while (!txTimedOut) {
       try {
+        ({ timestamp: latestBlockTimestamp } = await this.client.getBlock({
+          blockTag: 'latest',
+          includeTransactions: false,
+        }));
+
         const currentNonce = await this.client.getTransactionCount({ address: account.address });
         if (currentNonce > nonce) {
           for (const hash of txHashes) {
@@ -714,6 +723,16 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
           }
         }
 
+        this.logger?.trace(`Tx timeout check for ${currentTxHash}: ${isTimedOut()}`, {
+          latestBlockTimestamp: Number(latestBlockTimestamp) * 1000,
+          lastAttemptSent,
+          initialTxTime,
+          now: this.dateProvider.now(),
+          txTimeoutAt: gasConfig.txTimeoutAt?.getTime(),
+          txTimeoutMs: gasConfig.txTimeoutMs,
+          txStallTime: gasConfig.stallTimeMs,
+        });
+
         // Retry a few times, in case the tx is not yet propagated.
         const tx = await retry<GetTransactionReturnType>(
           () => this.client.getTransaction({ hash: currentTxHash }),
@@ -722,7 +741,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
           this.logger,
           true,
         );
-        const timePassed = Date.now() - lastAttemptSent;
+        const timePassed = this.dateProvider.now() - lastAttemptSent;
 
         if (tx && timePassed < gasConfig.stallTimeMs!) {
           this.logger?.debug(`L1 transaction ${currentTxHash} pending. Time passed: ${timePassed}ms.`);
@@ -784,7 +803,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
           currentTxHash = newHash;
 
           txHashes.add(currentTxHash);
-          lastAttemptSent = Date.now();
+          lastAttemptSent = this.dateProvider.now();
         }
         await sleep(gasConfig.checkIntervalMs!);
       } catch (err: any) {
@@ -807,12 +826,19 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
           metaMessages: viemError.metaMessages,
         });
       });
-
-      this.logger?.error(`L1 transaction ${currentTxHash} timed out`, {
-        txHash: currentTxHash,
-        ...tx,
-      });
     }
+
+    this.logger?.error(`L1 transaction ${currentTxHash} timed out`, {
+      txHash: currentTxHash,
+      txTimeoutAt: gasConfig.txTimeoutAt,
+      txTimeoutMs: gasConfig.txTimeoutMs,
+      txInitialTime: initialTxTime,
+      now: this.dateProvider.now(),
+      attempts,
+      isInterrupted: this.interrupted,
+      ...tx,
+    });
+
     throw new Error(`L1 transaction ${currentTxHash} timed out`);
   }
 

package/src/queries.ts

@@ -1,7 +1,7 @@
-import type { EthAddress } from '@aztec/foundation/eth-address';
-import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { SlasherAbi } from '@aztec/l1-artifacts/SlasherAbi';
 
-import type { Hex } from 'viem';
+import { getContract } from 'viem';
 
 import type { L1ContractsConfig } from './config.js';
 import { ReadOnlyGovernanceContract } from './contracts/governance.js';
@@ -27,6 +27,8 @@ export async function getL1ContractsConfig(
   const rollupAddress = addresses.rollupAddress ?? (await governanceProposer.getRollupAddress());
   const rollup = new RollupContract(publicClient, rollupAddress.toString());
   const slasherProposer = await rollup.getSlashingProposer();
+  const slasherAddress = await rollup.getSlasher();
+  const slasher = getContract({ address: slasherAddress, abi: SlasherAbi, client: publicClient });
 
   const [
     l1StartBlock,
@@ -35,12 +37,15 @@ export async function getL1ContractsConfig(
     aztecSlotDuration,
     aztecProofSubmissionEpochs,
     aztecTargetCommitteeSize,
-    depositAmount,
-    minimumStake,
+    activationThreshold,
+    ejectionThreshold,
     governanceProposerQuorum,
     governanceProposerRoundSize,
     slashingQuorum,
     slashingRoundSize,
+    slashingLifetimeInRounds,
+    slashingExecutionDelayInRounds,
+    slashingVetoer,
     manaTarget,
     provingCostPerMana,
     rollupVersion,
@@ -53,12 +58,15 @@ export async function getL1ContractsConfig(
     rollup.getSlotDuration(),
     rollup.getProofSubmissionEpochs(),
     rollup.getTargetCommitteeSize(),
-    rollup.getDepositAmount(),
-    rollup.getMinimumStake(),
+    rollup.getActivationThreshold(),
+    rollup.getEjectionThreshold(),
     governanceProposer.getQuorumSize(),
     governanceProposer.getRoundSize(),
     slasherProposer.getQuorumSize(),
     slasherProposer.getRoundSize(),
+    slasherProposer.getLifetimeInRounds(),
+    slasherProposer.getExecutionDelayInRounds(),
+    slasher.read.VETOER(),
     rollup.getManaTarget(),
     rollup.getProvingCostPerMana(),
     rollup.getVersion(),
@@ -75,10 +83,13 @@ export async function getL1ContractsConfig(
     aztecTargetCommitteeSize: Number(aztecTargetCommitteeSize),
     governanceProposerQuorum: Number(governanceProposerQuorum),
     governanceProposerRoundSize: Number(governanceProposerRoundSize),
-    depositAmount,
-    minimumStake,
+    activationThreshold,
+    ejectionThreshold,
     slashingQuorum: Number(slashingQuorum),
     slashingRoundSize: Number(slashingRoundSize),
+    slashingLifetimeInRounds: Number(slashingLifetimeInRounds),
+    slashingExecutionDelayInRounds: Number(slashingExecutionDelayInRounds),
+    slashingVetoer: EthAddress.fromString(slashingVetoer),
     manaTarget: manaTarget,
     provingCostPerMana: provingCostPerMana,
     rollupVersion: Number(rollupVersion),
@@ -86,25 +97,3 @@ export async function getL1ContractsConfig(
     exitDelaySeconds: Number(exitDelay),
   };
 }
-
-export type L2BlockProposedEvent = {
-  versionedBlobHashes: readonly Hex[];
-  archive: Hex;
-  blockNumber: bigint;
-};
-
-export async function getL2BlockProposalEvents(
-  client: ViemPublicClient,
-  blockId: Hex,
-  rollupAddress?: EthAddress,
-): Promise<L2BlockProposedEvent[]> {
-  return (
-    await client.getContractEvents({
-      abi: RollupAbi,
-      address: rollupAddress?.toString(),
-      blockHash: blockId,
-      eventName: 'L2BlockProposed',
-      strict: true,
-    })
-  ).map(log => log.args);
-}

package/src/test/chain_monitor.ts

@@ -1,6 +1,7 @@
 import { InboxContract, type RollupContract } from '@aztec/ethereum/contracts';
 import { createLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
+import { DateProvider } from '@aztec/foundation/timer';
 
 import { EventEmitter } from 'events';
 
@@ -18,6 +19,7 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
   private readonly l1Client: ViemClient;
   private inbox: InboxContract | undefined;
   private handle: NodeJS.Timeout | undefined;
+  // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
   private running: Set<Promise<void>> = new Set();
 
   /** Current L1 block number */
@@ -35,7 +37,8 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
 
   constructor(
     private readonly rollup: RollupContract,
-    private logger = createLogger('aztecjs:utils:chain_monitor'),
+    private readonly dateProvider: DateProvider = new DateProvider(),
+    private readonly logger = createLogger('aztecjs:utils:chain_monitor'),
     private readonly intervalMs = 200,
   ) {
     super();
@@ -129,10 +132,14 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
       this.emit('l2-messages', { totalL2Messages: newTotalL2Messages, l1BlockNumber: newL1BlockNumber });
     }
 
+    const [l2SlotNumber, l2Epoch] = await Promise.all([this.rollup.getSlotNumber(), this.rollup.getCurrentEpoch()]);
+
     this.logger.info(msg, {
+      currentTimestamp: this.dateProvider.nowInSeconds(),
       l1Timestamp: timestamp,
       l1BlockNumber: this.l1BlockNumber,
-      l2SlotNumber: await this.rollup.getSlotNumber(),
+      l2SlotNumber,
+      l2Epoch,
       l2BlockNumber: this.l2BlockNumber,
       l2ProvenBlockNumber: this.l2ProvenBlockNumber,
       totalL2Messages: this.totalL2Messages,

package/src/test/delayed_tx_utils.ts

@@ -5,7 +5,7 @@ export class DelayedTxUtils extends L1TxUtilsWithBlobs {
   public delayer: Delayer | undefined;
 
   public static fromL1TxUtils(l1TxUtils: L1TxUtilsWithBlobs, ethereumSlotDuration: number) {
-    const { client, delayer } = withDelayer(l1TxUtils.client, {
+    const { client, delayer } = withDelayer(l1TxUtils.client, l1TxUtils.dateProvider, {
       ethereumSlotDuration,
     });
     const casted = l1TxUtils as unknown as DelayedTxUtils;
@@ -15,7 +15,7 @@ export class DelayedTxUtils extends L1TxUtilsWithBlobs {
   }
 
   public enableDelayer(ethereumSlotDuration: number) {
-    const { client, delayer } = withDelayer(this.client, {
+    const { client, delayer } = withDelayer(this.client, this.dateProvider, {
       ethereumSlotDuration,
     });
     this.delayer = delayer;

package/src/{eth_cheat_codes.ts → test/eth_cheat_codes.ts}

@@ -7,7 +7,7 @@ import type { TestDateProvider } from '@aztec/foundation/timer';
 
 import { type Hex, createPublicClient, fallback, http } from 'viem';
 
-import type { ViemPublicClient } from './types.js';
+import type { ViemPublicClient } from '../types.js';
 
 /**
  * A class that provides utility functions for interacting with ethereum (L1).
@@ -163,26 +163,30 @@ export class EthCheatCodes {
    * Enable interval mining at the given interval (block time)
    * @param seconds - The interval to use between blocks
    */
-  public async setIntervalMining(seconds: number): Promise<void> {
+  public async setIntervalMining(seconds: number, opts: { silent?: boolean } = {}): Promise<void> {
     try {
       await this.rpcCall('anvil_setIntervalMining', [seconds]);
     } catch (err) {
       throw new Error(`Error setting interval mining: ${err}`);
     }
-    this.logger.warn(`Set L1 interval mining to ${seconds} seconds`);
+    if (!opts.silent) {
+      this.logger.warn(`Set L1 interval mining to ${seconds} seconds`);
+    }
   }
 
   /**
    * Set the automine status of the underlying anvil chain
    * @param automine - The automine status to set
    */
-  public async setAutomine(automine: boolean): Promise<void> {
+  public async setAutomine(automine: boolean, opts: { silent?: boolean } = {}): Promise<void> {
     try {
       await this.rpcCall('anvil_setAutomine', [automine]);
     } catch (err) {
       throw new Error(`Error setting automine: ${err}`);
     }
-    this.logger.warn(`Set L1 automine to ${automine}`);
+    if (!opts.silent) {
+      this.logger.warn(`Set L1 automine to ${automine}`);
+    }
   }
 
   /**
@@ -202,9 +206,11 @@ export class EthCheatCodes {
    * Set the next block timestamp
    * @param timestamp - The timestamp to set the next block to
    */
-  public async setNextBlockTimestamp(timestamp: number): Promise<void> {
+  public async setNextBlockTimestamp(timestamp: number | Date): Promise<void> {
     try {
-      await this.rpcCall('evm_setNextBlockTimestamp', [timestamp]);
+      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}`);
     }
@@ -227,7 +233,7 @@ export class EthCheatCodes {
       if (opts.resetBlockInterval) {
         blockInterval = await this.getIntervalMining();
         if (blockInterval !== null) {
-          await this.setIntervalMining(0);
+          await this.setIntervalMining(0, { silent: true });
         }
       }
       // Set the timestamp of the next block to be mined
@@ -241,7 +247,7 @@ export class EthCheatCodes {
     } 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);
+        await this.setIntervalMining(blockInterval, { silent: true });
       }
     }
     if (!opts.silent) {
@@ -418,15 +424,15 @@ export class EthCheatCodes {
     return this.rpcCall('trace_transaction', [txHash]);
   }
 
-  private async execWithPausedAnvil(fn: () => Promise<void>): Promise<void> {
+  public async execWithPausedAnvil(fn: () => Promise<void>): Promise<void> {
     const [blockInterval, wasAutoMining] = await Promise.all([this.getIntervalMining(), this.isAutoMining()]);
     try {
       if (blockInterval !== null) {
-        await this.setIntervalMining(0);
+        await this.setIntervalMining(0, { silent: true });
       }
 
       if (wasAutoMining) {
-        await this.setAutomine(false);
+        await this.setAutomine(false, { silent: true });
       }
 
       await fn();
@@ -434,7 +440,7 @@ export class EthCheatCodes {
       try {
         // restore automine if necessary
         if (wasAutoMining) {
-          await this.setAutomine(true);
+          await this.setAutomine(true, { silent: true });
         }
       } catch (err) {
         this.logger.warn(`Failed to reenable automining: ${err}`);
@@ -443,7 +449,7 @@ export class EthCheatCodes {
       try {
         // restore automine if necessary
         if (blockInterval !== null) {
-          await this.setIntervalMining(blockInterval);
+          await this.setIntervalMining(blockInterval, { silent: true });
         }
       } catch (err) {
         this.logger.warn(`Failed to reenable interval mining: ${err}`);

package/src/test/eth_cheat_codes_with_state.ts

@@ -1,6 +1,6 @@
 import fs from 'fs';
 
-import { EthCheatCodes } from '../eth_cheat_codes.js';
+import { EthCheatCodes } from './eth_cheat_codes.js';
 
 /**
  * A class that provides utility functions for interacting with ethereum (L1) dumping/loading state to/from a file.

package/src/test/index.ts

@@ -1,6 +1,8 @@
 export * from './delayed_tx_utils.js';
+export * from './eth_cheat_codes.js';
 export * from './eth_cheat_codes_with_state.js';
 export * from './start_anvil.js';
 export * from './tx_delayer.js';
 export * from './upgrade_utils.js';
 export * from './chain_monitor.js';
+export * from './rollup_cheat_codes.js';