@aztec/ethereum 0.0.1-commit.e558bd1c → 0.0.1-commit.e57c76e

package/src/{test → l1_tx_utils}/tx_delayer.ts

@@ -1,5 +1,5 @@
 import { omit } from '@aztec/foundation/collection';
-import { type Logger, createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
 import type { DateProvider } from '@aztec/foundation/timer';
 
@@ -9,14 +9,16 @@ import {
   type Hex,
   type PublicClient,
   type TransactionSerializableEIP4844,
+  type TransactionSerialized,
   keccak256,
   parseTransaction,
   publicActions,
+  recoverTransactionAddress,
   serializeTransaction,
   walletActions,
 } from 'viem';
 
-import { type ViemClient, isExtendedClient } from '../types.js';
+import type { ExtendedViemWalletClient, ViemClient } from '../types.js';
 
 const MAX_WAIT_TIME_SECONDS = 180;
 
@@ -73,82 +75,102 @@ export function waitUntilL1Timestamp<T extends Client>(
   );
 }
 
-export interface Delayer {
-  /** Returns the hashes of all effectively sent txs. */
-  getSentTxHashes(): Hex[];
-  /** Returns the raw hex for all cancelled txs. */
-  getCancelledTxs(): Hex[];
-  /** Delays the next tx to be sent so it lands on the given L1 block number. */
-  pauseNextTxUntilBlock(l1BlockNumber: number | bigint | undefined): void;
-  /** Delays the next tx to be sent so it lands on the given timestamp. */
-  pauseNextTxUntilTimestamp(l1Timestamp: number | bigint | undefined): void;
-  /** Delays the next tx to be sent indefinitely. */
-  cancelNextTx(): void;
-  /**
-   * Sets max inclusion time into slot. If more than this many seconds have passed
-   * since the last L1 block was mined, then any tx will not be mined in the current
-   * L1 slot but will be deferred for the next one.
-   */
-  setMaxInclusionTimeIntoSlot(seconds: number | bigint | undefined): void;
-}
+/** Manages tx delaying for testing, intercepting sendRawTransaction calls to delay or cancel them. */
+export class Delayer {
+  private logger: Logger;
+
+  public maxInclusionTimeIntoSlot: number | undefined = undefined;
+  public ethereumSlotDuration: bigint;
+  public nextWait:
+    | { l1Timestamp: bigint; timeoutSeconds?: number }
+    | { l1BlockNumber: bigint; timeoutSeconds?: number }
+    | { indefinitely: true }
+    | undefined = undefined;
+  public sentTxHashes: Hex[] = [];
+  public cancelledTxs: Hex[] = [];
 
-class DelayerImpl implements Delayer {
-  private logger = createLogger('ethereum:tx_delayer');
   constructor(
     public dateProvider: DateProvider,
     opts: { ethereumSlotDuration: bigint | number },
+    bindings: LoggerBindings,
   ) {
     this.ethereumSlotDuration = BigInt(opts.ethereumSlotDuration);
+    this.logger = createLogger('ethereum:tx_delayer', bindings);
   }
 
-  public maxInclusionTimeIntoSlot: number | undefined = undefined;
-  public ethereumSlotDuration: bigint;
-  public nextWait: { l1Timestamp: bigint } | { l1BlockNumber: bigint } | { indefinitely: true } | undefined = undefined;
-  public sentTxHashes: Hex[] = [];
-  public cancelledTxs: Hex[] = [];
+  /** Returns the logger instance used by this delayer. */
+  getLogger(): Logger {
+    return this.logger;
+  }
 
+  /** Returns the hashes of all effectively sent txs. */
   getSentTxHashes() {
     return this.sentTxHashes;
   }
 
+  /** Returns the raw hex for all cancelled txs. */
   getCancelledTxs(): Hex[] {
     return this.cancelledTxs;
   }
 
-  pauseNextTxUntilBlock(l1BlockNumber: number | bigint) {
-    this.nextWait = { l1BlockNumber: BigInt(l1BlockNumber) };
+  /** Delays the next tx to be sent so it lands on the given L1 block number. */
+  pauseNextTxUntilBlock(l1BlockNumber: number | bigint, timeoutSeconds?: number) {
+    this.nextWait = { l1BlockNumber: BigInt(l1BlockNumber), timeoutSeconds };
   }
 
-  pauseNextTxUntilTimestamp(l1Timestamp: number | bigint) {
-    this.nextWait = { l1Timestamp: BigInt(l1Timestamp) };
+  /** Delays the next tx to be sent so it lands on the given timestamp. */
+  pauseNextTxUntilTimestamp(l1Timestamp: number | bigint, timeoutSeconds?: number) {
+    this.nextWait = { l1Timestamp: BigInt(l1Timestamp), timeoutSeconds };
   }
 
+  /** Delays the next tx to be sent indefinitely. */
   cancelNextTx() {
     this.nextWait = { indefinitely: true };
   }
 
+  /**
+   * Sets max inclusion time into slot. If more than this many seconds have passed
+   * since the last L1 block was mined, then any tx will not be mined in the current
+   * L1 slot but will be deferred for the next one.
+   */
   setMaxInclusionTimeIntoSlot(seconds: number | undefined) {
     this.maxInclusionTimeIntoSlot = seconds;
   }
 }
 
 /**
- * Returns a new client (without modifying the one passed in) with an injected tx delayer.
- * The delayer can be used to hold off the next tx to be sent until a given block number.
- * TODO(#10824): This doesn't play along well with blob txs for some reason.
+ * Creates a new Delayer instance. Exposed so callers can create a single shared delayer
+ * and pass it to multiple `wrapClientWithDelayer` calls.
  */
-export function withDelayer<T extends ViemClient>(
-  client: T,
+export function createDelayer(
   dateProvider: DateProvider,
   opts: { ethereumSlotDuration: bigint | number },
-): { client: T; delayer: Delayer } {
-  if (!isExtendedClient(client)) {
-    throw new Error('withDelayer has to be instantiated with a wallet viem client.');
+  bindings: LoggerBindings,
+): Delayer {
+  return new Delayer(dateProvider, opts, bindings);
+}
+
+/** Tries to recover the sender address from a serialized signed transaction. */
+async function tryRecoverSender(serializedTransaction: Hex): Promise<string | undefined> {
+  try {
+    return await recoverTransactionAddress({
+      serializedTransaction: serializedTransaction as TransactionSerialized,
+    });
+  } catch {
+    return undefined;
   }
-  const logger = createLogger('ethereum:tx_delayer');
-  const delayer = new DelayerImpl(dateProvider, opts);
+}
 
-  const extended = client
+/**
+ * Wraps a viem client with tx delaying logic. Returns the wrapped client.
+ * The delayer intercepts sendRawTransaction calls and delays them based on the delayer's state.
+ */
+export function wrapClientWithDelayer<T extends ViemClient>(client: T, delayer: Delayer): T {
+  const logger = delayer.getLogger();
+
+  // Cast to ExtendedViemWalletClient for the extend chain since it has sendRawTransaction.
+  // The sendRawTransaction override is applied to all clients regardless of type.
+  const withRawTx = (client as unknown as ExtendedViemWalletClient)
     // Tweak sendRawTransaction so it uses the delay defined in the delayer.
     // Note that this will only work with local accounts (ie accounts for which we have the private key).
     // Transactions signed by the node will not be delayed since they use sendTransaction directly,
@@ -160,6 +182,7 @@ export function withDelayer<T extends ViemClient>(
 
         const { serializedTransaction } = args[0];
         const publicClient = client as unknown as PublicClient;
+        const sender = await tryRecoverSender(serializedTransaction);
 
         if (delayer.nextWait !== undefined) {
           // Check if we have been instructed to delay the next tx.
@@ -171,7 +194,7 @@ export function withDelayer<T extends ViemClient>(
 
           // Cancel tx outright if instructed
           if ('indefinitely' in waitUntil && waitUntil.indefinitely) {
-            logger.info(`Cancelling tx ${txHash}`);
+            logger.info(`Cancelling tx ${txHash}`, { sender });
             delayer.cancelledTxs.push(serializedTransaction);
             return Promise.resolve(txHash);
           }
@@ -179,12 +202,18 @@ export function withDelayer<T extends ViemClient>(
           // Or wait until the desired block number or timestamp
           wait =
             'l1BlockNumber' in waitUntil
-              ? waitUntilBlock(publicClient, waitUntil.l1BlockNumber - 1n, logger)
+              ? waitUntilBlock(publicClient, waitUntil.l1BlockNumber - 1n, logger, waitUntil.timeoutSeconds)
               : 'l1Timestamp' in waitUntil
-                ? waitUntilL1Timestamp(publicClient, waitUntil.l1Timestamp - delayer.ethereumSlotDuration, logger)
+                ? waitUntilL1Timestamp(
+                    publicClient,
+                    waitUntil.l1Timestamp - delayer.ethereumSlotDuration,
+                    logger,
+                    waitUntil.timeoutSeconds,
+                  )
                 : undefined;
 
           logger.info(`Delaying tx ${txHash} until ${inspect(waitUntil)}`, {
+            sender,
             argsLen: args.length,
             ...omit(parseTransaction(serializedTransaction), 'data', 'sidecars'),
           });
@@ -196,6 +225,7 @@ export function withDelayer<T extends ViemClient>(
 
           txHash = computeTxHash(serializedTransaction);
           const logData = {
+            sender,
             ...omit(parseTransaction(serializedTransaction), 'data', 'sidecars'),
             lastBlockTimestamp,
             now,
@@ -225,28 +255,35 @@ export function withDelayer<T extends ViemClient>(
                   computedTxHash: txHash,
                 });
               }
-              logger.info(`Sent previously delayed tx ${clientTxHash}`);
+              logger.info(`Sent previously delayed tx ${clientTxHash}`, { sender });
               delayer.sentTxHashes.push(clientTxHash);
             })
             .catch(err => logger.error(`Error sending tx after delay`, err));
           return Promise.resolve(txHash!);
         } else {
           const txHash = await client.sendRawTransaction(...args);
-          logger.debug(`Sent tx immediately ${txHash}`);
+          logger.debug(`Sent tx immediately ${txHash}`, { sender });
           delayer.sentTxHashes.push(txHash);
           return txHash;
         }
       },
-    }))
-    // Re-extend with sendTransaction so it uses the modified sendRawTransaction.
-    .extend(client => ({ sendTransaction: walletActions(client).sendTransaction }))
-    // And with the actions that depend on the modified sendTransaction
-    .extend(client => ({
-      writeContract: walletActions(client).writeContract,
-      deployContract: walletActions(client).deployContract,
-    })) as T;
+    }));
+
+  // Only re-bind wallet actions (sendTransaction, writeContract, deployContract) for wallet clients.
+  // This is needed for tests that use wallet actions directly rather than sendRawTransaction.
+  const isWalletClient = 'account' in client && client.account !== undefined;
+  const extended = isWalletClient
+    ? withRawTx
+        // Re-extend with sendTransaction so it uses the modified sendRawTransaction.
+        .extend(client => ({ sendTransaction: walletActions(client).sendTransaction }))
+        // And with the actions that depend on the modified sendTransaction
+        .extend(client => ({
+          writeContract: walletActions(client).writeContract,
+          deployContract: walletActions(client).deployContract,
+        }))
+    : withRawTx;
 
-  return { client: extended, delayer };
+  return extended as T;
 }
 
 /**

package/src/publisher_manager.ts

@@ -1,6 +1,8 @@
 import { pick } from '@aztec/foundation/collection';
 import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
 
+import { Multicall3 } from './contracts/multicall.js';
 import { L1TxUtils, TxUtilsState } from './l1_tx_utils/index.js';
 
 // Defines the order in which we prioritise publishers based on their state (first is better)
@@ -27,24 +29,72 @@ const busyStates: TxUtilsState[] = [
 
 export type PublisherFilter<UtilsType extends L1TxUtils> = (utils: UtilsType) => boolean;
 
+/** Config accepted by PublisherManager. */
+type PublisherManagerConfig = {
+  publisherAllowInvalidStates?: boolean;
+  publisherFundingThreshold?: bigint;
+  publisherFundingAmount?: bigint;
+};
+
 export class PublisherManager<UtilsType extends L1TxUtils = L1TxUtils> {
   private log: Logger;
-  private config: { publisherAllowInvalidStates?: boolean };
+  private config: PublisherManagerConfig;
+  private static readonly FUNDING_CHECK_INTERVAL_MS = 2 * 60 * 1000;
+  private funder?: UtilsType;
+  private fundingPromise?: RunningPromise;
 
   constructor(
     private publishers: UtilsType[],
-    config: { publisherAllowInvalidStates?: boolean },
-    bindings?: LoggerBindings,
+    config: PublisherManagerConfig,
+    opts?: { bindings?: LoggerBindings; funder?: UtilsType },
   ) {
-    this.log = createLogger('publisher:manager', bindings);
+    this.funder = opts?.funder;
+    this.log = createLogger('publisher:manager', opts?.bindings);
     this.log.info(`PublisherManager initialized with ${publishers.length} publishers.`);
     this.publishers = publishers;
-    this.config = pick(config, 'publisherAllowInvalidStates');
+    this.config = pick(config, 'publisherAllowInvalidStates', 'publisherFundingThreshold', 'publisherFundingAmount');
+
+    const hasThreshold = this.config.publisherFundingThreshold !== undefined;
+    const hasAmount = this.config.publisherFundingAmount !== undefined;
+    if (hasThreshold !== hasAmount) {
+      this.log.warn(`Incomplete funding config: both publisherFundingThreshold and publisherFundingAmount must be set`);
+    }
+
+    if (this.funder) {
+      const funderAddress = this.funder.getSenderAddress();
+      if (publishers.some(p => p.getSenderAddress().equals(funderAddress))) {
+        this.log.error(`Funding account ${funderAddress} is also a publisher, disabling funding to avoid self-funding`);
+        this.funder = undefined;
+      }
+    }
   }
 
-  /** Loads the state of all publishers and resumes monitoring any pending txs */
-  public async loadState(): Promise<void> {
-    await Promise.all(this.publishers.map(pub => pub.loadStateAndResumeMonitoring()));
+  /** Loads the state of all publishers and the funder, and starts periodic funding checks. */
+  public async start(): Promise<void> {
+    await Promise.all([
+      ...this.publishers.map(pub => pub.loadStateAndResumeMonitoring()),
+      this.funder?.loadStateAndResumeMonitoring(),
+    ]);
+
+    if (
+      this.funder &&
+      this.config.publisherFundingThreshold !== undefined &&
+      this.config.publisherFundingAmount !== undefined
+    ) {
+      this.fundingPromise = new RunningPromise(
+        () => this.triggerFundingIfNeeded(),
+        this.log,
+        PublisherManager.FUNDING_CHECK_INTERVAL_MS,
+      );
+      this.fundingPromise.start();
+    }
+  }
+
+  /** Stops the funding loop and interrupts all publishers. */
+  public async stop(): Promise<void> {
+    await this.fundingPromise?.stop();
+    this.publishers.forEach(pub => pub.interrupt());
+    this.funder?.interrupt();
   }
 
   // Finds and prioritises available publishers based on
@@ -102,7 +152,52 @@ export class PublisherManager<UtilsType extends L1TxUtils = L1TxUtils> {
     return sortedPublishers[0].publisher;
   }
 
-  public interrupt() {
-    this.publishers.forEach(pub => pub.interrupt());
+  /** Check all publisher balances and fund those below threshold. */
+  private async triggerFundingIfNeeded(): Promise<void> {
+    const { funder, config } = this;
+    if (!funder || config.publisherFundingThreshold === undefined || config.publisherFundingAmount === undefined) {
+      return;
+    }
+
+    const allBalances = await Promise.all(
+      this.publishers.map(async pub => ({ balance: await pub.getSenderBalance(), publisher: pub })),
+    );
+    const lowBalance = allBalances.filter(p => p.balance < config.publisherFundingThreshold!);
+    if (lowBalance.length === 0) {
+      return;
+    }
+
+    const fundingAmount = config.publisherFundingAmount!;
+    const funderBalance = await funder.getSenderBalance();
+
+    if (funderBalance < 10n * fundingAmount) {
+      this.log.warn(`Funding account balance is low`, { funderBalance, threshold: 10n * fundingAmount });
+    }
+    const affordableCount = Number(funderBalance / fundingAmount);
+    if (affordableCount === 0) {
+      this.log.error(`Funding account balance too low to fund any publisher`, { funderBalance, fundingAmount });
+      return;
+    }
+    if (affordableCount < lowBalance.length) {
+      this.log.warn(`Funder can only afford ${affordableCount}/${lowBalance.length} publishers`, {
+        funderBalance,
+        fundingAmount,
+      });
+    }
+
+    const toFund = lowBalance.slice(0, affordableCount).map(p => p.publisher);
+    await this.fundPublishers(toFund);
+  }
+
+  /** Fund publishers via a single Multicall3 aggregate3Value transaction. */
+  private async fundPublishers(publishers: UtilsType[]): Promise<void> {
+    const fundingAmount = this.config.publisherFundingAmount!;
+    const calls = publishers.map(pub => ({
+      to: pub.getSenderAddress().toString(),
+      value: fundingAmount,
+    }));
+
+    await Multicall3.forwardValue(calls, this.funder!, this.log);
+    this.log.info(`Funded ${publishers.length} publishers`);
   }
 }

package/src/queries.ts

@@ -1,11 +1,77 @@
 import { EthAddress } from '@aztec/foundation/eth-address';
 
+import { BaseError, type Block } from 'viem';
+
 import { DefaultL1ContractsConfig, type L1ContractsConfig } from './config.js';
 import { ReadOnlyGovernanceContract } from './contracts/governance.js';
 import { GovernanceProposerContract } from './contracts/governance_proposer.js';
 import { InboxContract } from './contracts/inbox.js';
 import { RollupContract } from './contracts/rollup.js';
-import type { ViemPublicClient } from './types.js';
+import type { ViemClient, ViemPublicClient } from './types.js';
+
+/**
+ * Returns the L1 finalized block, or `undefined` if the chain does not yet have one
+ * (common on freshly started devnets). Rethrows any other RPC error.
+ */
+export async function getFinalizedL1Block(client: ViemClient): Promise<Block<bigint, false, 'finalized'> | undefined> {
+  try {
+    return await client.getBlock({ blockTag: 'finalized', includeTransactions: false });
+  } catch (err) {
+    if (isFinalizedBlockTagNotFoundError(err)) {
+      return undefined;
+    }
+    throw err;
+  }
+}
+
+// Error messages returned by popular Ethereum execution clients when
+// eth_getBlockByNumber / eth_call is called with blockTag "finalized" or
+// "safe" and no such block has been produced yet:
+//
+//   geth       "finalized block not found"
+//              "safe block not found"
+//   reth       "block not found: finalized"
+//              "block not found: safe"
+//   nethermind "Unknown block error"           (same for both tags)
+//   besu       "Unknown block"
+//   erigon     'block "finalized" not available (head block: N)'
+//              'block "safe" not available (head block: N)'
+//
+// A combined regex covers all five:
+const FINALIZED_BLOCK_TAG_NOT_FOUND_MESSAGE_RE =
+  /(finalized|safe) block not found|block not found: (finalized|safe)|unknown block|block "(finalized|safe)" not available/i;
+
+/**
+ * Returns true if the error originates from an RPC call that failed because
+ * the "finalized" (or "safe") block tag is not yet available on the chain.
+ */
+export function isFinalizedBlockTagNotFoundError(err: unknown): boolean {
+  if (!err) {
+    return false;
+  }
+
+  if (err instanceof BaseError) {
+    const hit = err.walk((e: any) => matchesFinalizedBlockTagNotFound(e));
+    if (hit) {
+      return true;
+    }
+  }
+
+  for (let cur: any = err, i = 0; cur && i < 10; cur = cur.cause, i++) {
+    if (matchesFinalizedBlockTagNotFound(cur)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function matchesFinalizedBlockTagNotFound(e: any): boolean {
+  if (!e) {
+    return false;
+  }
+  const text = `${e.details ?? ''} ${e.message ?? ''} ${e.shortMessage ?? ''}`;
+  return FINALIZED_BLOCK_TAG_NOT_FOUND_MESSAGE_RE.test(text);
+}
 
 /** Reads the L1ContractsConfig from L1 contracts. */
 export async function getL1ContractsConfig(
@@ -76,8 +142,8 @@ export async function getL1ContractsConfig(
     slasherProposer?.getRoundSize() ?? 0n,
     slasherProposer?.getLifetimeInRounds() ?? 0n,
     slasherProposer?.getExecutionDelayInRounds() ?? 0n,
-    slasherProposer?.type === 'tally' ? slasherProposer.getSlashOffsetInRounds() : 0n,
-    slasherProposer?.type === 'tally' ? slasherProposer.getSlashingAmounts() : [0n, 0n, 0n],
+    slasherProposer?.getSlashOffsetInRounds() ?? 0n,
+    slasherProposer?.getSlashingAmounts() ?? [0n, 0n, 0n],
     slasher?.getVetoer() ?? EthAddress.ZERO,
     slasher?.getSlashingDisableDuration() ?? 0,
     rollup.getManaTarget(),
@@ -114,7 +180,7 @@ export async function getL1ContractsConfig(
     rollupVersion: Number(rollupVersion),
     genesisArchiveTreeRoot: genesisArchiveTreeRoot.toString(),
     exitDelaySeconds: Number(exitDelay),
-    slasherFlavor: slasherProposer?.type ?? 'tally',
+    slasherEnabled: !!slasherProposer,
     slashingOffsetInRounds: Number(slashingOffsetInRounds),
     slashAmountSmall: slashingAmounts[0],
     slashAmountMedium: slashingAmounts[1],

package/src/test/chain_monitor.ts

@@ -1,4 +1,4 @@
-import type { RollupContract } from '@aztec/ethereum/contracts';
+import type { ManaMinFeeComponents, RollupContract } from '@aztec/ethereum/contracts';
 import { InboxContract } from '@aztec/ethereum/contracts';
 import { CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { EthAddress } from '@aztec/foundation/eth-address';
@@ -10,6 +10,20 @@ import { EventEmitter } from 'events';
 
 import type { ViemClient } from '../types.js';
 
+/** L2 fee data reported by the chain monitor. */
+export type L2FeeData = ManaMinFeeComponents & {
+  /** Total minimum fee per mana in Fee Juice (sum of sequencerCost + proverCost + congestionCost). */
+  minFeePerMana: bigint;
+  /** L1 base fee observed by the oracle. */
+  l1BaseFee: bigint;
+  /** L1 blob fee observed by the oracle. */
+  l1BlobFee: bigint;
+  /** ETH per fee asset exchange rate (1e12 precision). */
+  ethPerFeeAsset: bigint;
+  /** Mana target per checkpoint. */
+  manaTarget: bigint;
+};
+
 export type ChainMonitorEventMap = {
   'l1-block': [{ l1BlockNumber: number; timestamp: bigint }];
   checkpoint: [
@@ -19,6 +33,7 @@ export type ChainMonitorEventMap = {
   'l2-messages': [{ totalL2Messages: number; l1BlockNumber: number }];
   'l2-epoch': [{ l2EpochNumber: EpochNumber; timestamp: bigint; committee: EthAddress[] | undefined }];
   'l2-slot': [{ l2SlotNumber: SlotNumber; timestamp: bigint }];
+  'l2-fees': [L2FeeData];
 };
 
 /** Utility class that polls the chain on quick intervals and logs new L1 blocks, L2 blocks, and L2 proofs. */
@@ -45,6 +60,8 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
   public l2EpochNumber!: EpochNumber;
   /** Current L2 slot number */
   public l2SlotNumber!: SlotNumber;
+  /** Current L2 fee data (components of the minimum fee per mana). */
+  public l2FeeData!: L2FeeData;
 
   constructor(
     private readonly rollup: RollupContract,
@@ -77,7 +94,7 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
     }
   }
 
-  private async getInbox() {
+  protected async getInbox() {
     if (!this.inbox) {
       const { inboxAddress } = await this.rollup.getRollupAddresses();
       this.inbox = new InboxContract(this.l1Client, inboxAddress);
@@ -158,7 +175,7 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
       this.l2EpochNumber = l2Epoch;
       committee = await this.rollup.getCurrentEpochCommittee();
       this.emit('l2-epoch', { l2EpochNumber: l2Epoch, timestamp, committee });
-      msg += ` starting new epoch ${this.l2EpochNumber} `;
+      msg += ` starting new epoch ${this.l2EpochNumber}`;
     }
 
     if (l2SlotNumber !== this.l2SlotNumber) {
@@ -166,6 +183,13 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
       this.emit('l2-slot', { l2SlotNumber, timestamp });
     }
 
+    const feeData = await this.fetchFeeData(timestamp);
+    if (this.hasFeeDataChanged(feeData)) {
+      msg += ` with L2 min fee ${feeData.minFeePerMana}`;
+      this.l2FeeData = feeData;
+      this.emit('l2-fees', feeData);
+    }
+
     this.logger.info(msg, {
       currentTimestamp: this.dateProvider.nowInSeconds(),
       l1Timestamp: timestamp,
@@ -176,6 +200,7 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
       provenCheckpointNumber: this.provenCheckpointNumber,
       totalL2Messages: this.totalL2Messages,
       committee,
+      ...this.l2FeeData,
     });
 
     return this;
@@ -196,6 +221,11 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
     });
   }
 
+  public async waitUntilNextL2Slot(): Promise<void> {
+    const targetSlot = SlotNumber.add((await this.run()).l2SlotNumber, 1);
+    return this.waitUntilL2Slot(targetSlot);
+  }
+
   public waitUntilL1Block(block: number | bigint): Promise<void> {
     const targetBlock = typeof block === 'bigint' ? block.valueOf() : block;
     if (this.l1BlockNumber >= targetBlock) {
@@ -242,4 +272,36 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
       this.on('checkpoint', listener);
     });
   }
+
+  private async fetchFeeData(timestamp: bigint): Promise<L2FeeData> {
+    const [components, minFeePerMana, l1Fees, ethPerFeeAsset, manaTarget] = await Promise.all([
+      this.rollup.getManaMinFeeComponentsAt(timestamp, true),
+      this.rollup.getManaMinFeeAt(timestamp, true),
+      this.rollup.getL1FeesAt(timestamp),
+      this.rollup.getEthPerFeeAsset(),
+      this.rollup.getManaTarget(),
+    ]);
+    return {
+      ...components,
+      minFeePerMana,
+      l1BaseFee: l1Fees.baseFee,
+      l1BlobFee: l1Fees.blobFee,
+      ethPerFeeAsset,
+      manaTarget,
+    };
+  }
+
+  private hasFeeDataChanged(newData: L2FeeData): boolean {
+    if (!this.l2FeeData) {
+      return true;
+    }
+    return (
+      this.l2FeeData.sequencerCost !== newData.sequencerCost ||
+      this.l2FeeData.proverCost !== newData.proverCost ||
+      this.l2FeeData.congestionCost !== newData.congestionCost ||
+      this.l2FeeData.l1BaseFee !== newData.l1BaseFee ||
+      this.l2FeeData.l1BlobFee !== newData.l1BlobFee ||
+      this.l2FeeData.ethPerFeeAsset !== newData.ethPerFeeAsset
+    );
+  }
 }

package/src/test/eth_cheat_codes.ts

@@ -85,14 +85,26 @@ export class EthCheatCodes {
   }
 
   /**
-   * Get the current timestamp
-   * @returns The current timestamp
+   * Get the timestamp of the latest mined L1 block.
+   * Note: this is NOT the current time — it's the discrete timestamp of the last block.
+   * Between blocks, the actual chain time advances but no new block reflects it.
+   * @returns The latest block timestamp in seconds
    */
-  public async timestamp(): Promise<number> {
+  public async lastBlockTimestamp(): Promise<number> {
     const res = await this.doRpcCall('eth_getBlockByNumber', ['latest', true]);
     return parseInt(res.timestamp, 16);
   }
 
+  /**
+   * Get the timestamp of the pending L1 block — the block that anvil will mine next.
+   * Reflects any prior `setNextBlockTimestamp` call or the configured block interval.
+   * @returns The pending block timestamp in seconds.
+   */
+  public async nextBlockTimestamp(): Promise<number> {
+    const res = await this.doRpcCall('eth_getBlockByNumber', ['pending', false]);
+    return parseInt(res.timestamp, 16);
+  }
+
   /**
    * Advance the chain by a number of blocks
    * @param numberOfBlocks - The number of blocks to mine
@@ -552,7 +564,7 @@ export class EthCheatCodes {
   }
 
   public async syncDateProvider() {
-    const timestamp = await this.timestamp();
+    const timestamp = await this.lastBlockTimestamp();
     if ('setTime' in this.dateProvider) {
       this.dateProvider.setTime(timestamp * 1000);
     }