@aztec/ethereum 0.0.1-commit.9b94fc1 → 0.0.1-commit.9ee6fcc6

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,18 @@ 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;
 
 export function waitUntilBlock<T extends Client>(
   client: T,
@@ -36,7 +40,7 @@ export function waitUntilBlock<T extends Client>(
       return currentBlockNumber >= BigInt(blockNumber);
     },
     `Wait until L1 block ${blockNumber}`,
-    timeout ?? 120,
+    timeout ?? MAX_WAIT_TIME_SECONDS,
     0.1,
   );
 }
@@ -66,87 +70,103 @@ export function waitUntilL1Timestamp<T extends Client>(
       return currentTs >= BigInt(timestamp);
     },
     `Wait until L1 timestamp ${timestamp}`,
-    timeout ?? 120,
+    timeout ?? MAX_WAIT_TIME_SECONDS,
     0.1,
   );
 }
 
-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 } | { l1BlockNumber: bigint } | { 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;
   }
 
+  /** Delays the next tx to be sent so it lands on the given L1 block number. */
   pauseNextTxUntilBlock(l1BlockNumber: number | bigint) {
     this.nextWait = { l1BlockNumber: BigInt(l1BlockNumber) };
   }
 
+  /** Delays the next tx to be sent so it lands on the given timestamp. */
   pauseNextTxUntilTimestamp(l1Timestamp: number | bigint) {
     this.nextWait = { l1Timestamp: BigInt(l1Timestamp) };
   }
 
+  /** 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,
@@ -158,6 +178,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.
@@ -169,7 +190,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);
           }
@@ -183,6 +204,7 @@ export function withDelayer<T extends ViemClient>(
                 : undefined;
 
           logger.info(`Delaying tx ${txHash} until ${inspect(waitUntil)}`, {
+            sender,
             argsLen: args.length,
             ...omit(parseTransaction(serializedTransaction), 'data', 'sidecars'),
           });
@@ -194,6 +216,7 @@ export function withDelayer<T extends ViemClient>(
 
           txHash = computeTxHash(serializedTransaction);
           const logData = {
+            sender,
             ...omit(parseTransaction(serializedTransaction), 'data', 'sidecars'),
             lastBlockTimestamp,
             now,
@@ -223,28 +246,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.verbose(`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 { createLogger } from '@aztec/foundation/log';
+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,22 +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 = createLogger('publisher:manager');
-  private config: { publisherAllowInvalidStates?: boolean };
+  private log: Logger;
+  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 },
+    config: PublisherManagerConfig,
+    opts?: { bindings?: LoggerBindings; funder?: UtilsType },
   ) {
+    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
@@ -100,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,8 +1,9 @@
 import { EthAddress } from '@aztec/foundation/eth-address';
 
-import type { L1ContractsConfig } from './config.js';
+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';
 
@@ -25,6 +26,8 @@ export async function getL1ContractsConfig(
   const rollup = new RollupContract(publicClient, rollupAddress.toString());
   const slasherProposer = await rollup.getSlashingProposer();
   const slasher = await rollup.getSlasherContract();
+  const rollupAddresses = await rollup.getRollupAddresses();
+  const inboxContract = new InboxContract(publicClient, rollupAddresses.inboxAddress.toString());
 
   const [
     l1StartBlock,
@@ -35,6 +38,7 @@ export async function getL1ContractsConfig(
     aztecTargetCommitteeSize,
     lagInEpochsForValidatorSet,
     lagInEpochsForRandao,
+    inboxLag,
     activationThreshold,
     ejectionThreshold,
     localEjectionThreshold,
@@ -62,6 +66,7 @@ export async function getL1ContractsConfig(
     rollup.getTargetCommitteeSize(),
     rollup.getLagInEpochsForValidatorSet(),
     rollup.getLagInEpochsForRandao(),
+    inboxContract.getLag(),
     rollup.getActivationThreshold(),
     rollup.getEjectionThreshold(),
     rollup.getLocalEjectionThreshold(),
@@ -91,13 +96,15 @@ export async function getL1ContractsConfig(
     aztecTargetCommitteeSize: Number(aztecTargetCommitteeSize),
     lagInEpochsForValidatorSet: Number(lagInEpochsForValidatorSet),
     lagInEpochsForRandao: Number(lagInEpochsForRandao),
+    inboxLag: Number(inboxLag),
     governanceProposerQuorum: Number(governanceProposerQuorum),
     governanceProposerRoundSize: Number(governanceProposerRoundSize),
+    governanceVotingDuration: DefaultL1ContractsConfig.governanceVotingDuration,
     activationThreshold,
     ejectionThreshold,
     localEjectionThreshold,
     slashingQuorum: Number(slashingQuorum),
-    slashingRoundSizeInEpochs: Number(slashingRoundSize / aztecEpochDuration),
+    slashingRoundSizeInEpochs: Number(Number(slashingRoundSize) / aztecEpochDuration),
     slashingLifetimeInRounds: Number(slashingLifetimeInRounds),
     slashingExecutionDelayInRounds: Number(slashingExecutionDelayInRounds),
     slashingVetoer,
@@ -105,12 +112,13 @@ export async function getL1ContractsConfig(
     manaTarget,
     provingCostPerMana: provingCostPerMana,
     rollupVersion: Number(rollupVersion),
-    genesisArchiveTreeRoot,
+    genesisArchiveTreeRoot: genesisArchiveTreeRoot.toString(),
     exitDelaySeconds: Number(exitDelay),
     slasherFlavor: slasherProposer?.type ?? 'tally',
     slashingOffsetInRounds: Number(slashingOffsetInRounds),
     slashAmountSmall: slashingAmounts[0],
     slashAmountMedium: slashingAmounts[1],
     slashAmountLarge: slashingAmounts[2],
+    initialEthPerFeeAsset: DefaultL1ContractsConfig.initialEthPerFeeAsset,
   };
 }

package/src/test/chain_monitor.ts

@@ -1,5 +1,6 @@
-import { InboxContract, type RollupContract } from '@aztec/ethereum/contracts';
-import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+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';
 import { createLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
@@ -9,13 +10,30 @@ 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: [{ checkpointNumber: number; l1BlockNumber: number; l2SlotNumber: SlotNumber; timestamp: bigint }];
-  'checkpoint-proven': [{ provenCheckpointNumber: number; l1BlockNumber: number; timestamp: bigint }];
+  checkpoint: [
+    { checkpointNumber: CheckpointNumber; l1BlockNumber: number; l2SlotNumber: SlotNumber; timestamp: bigint },
+  ];
+  'checkpoint-proven': [{ provenCheckpointNumber: CheckpointNumber; l1BlockNumber: number; timestamp: bigint }];
   '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. */
@@ -29,9 +47,9 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
   /** Current L1 block number */
   public l1BlockNumber!: number;
   /** Current checkpoint number */
-  public checkpointNumber!: number;
+  public checkpointNumber!: CheckpointNumber;
   /** Current proven checkpoint number */
-  public provenCheckpointNumber!: number;
+  public provenCheckpointNumber!: CheckpointNumber;
   /** L1 timestamp for the current checkpoint */
   public checkpointTimestamp!: bigint;
   /** L1 timestamp for the proven checkpoint */
@@ -42,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,
@@ -74,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);
@@ -115,9 +135,9 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
     this.emit('l1-block', { l1BlockNumber: newL1BlockNumber, timestamp });
     let msg = `L1 block ${newL1BlockNumber} mined at ${timestampString}`;
 
-    const newCheckpointNumber = Number(await this.rollup.getCheckpointNumber());
+    const newCheckpointNumber = await this.rollup.getCheckpointNumber();
     if (this.checkpointNumber !== newCheckpointNumber) {
-      const epochNumber = await this.rollup.getEpochNumberForCheckpoint(BigInt(newCheckpointNumber));
+      const epochNumber = await this.rollup.getEpochNumberForCheckpoint(newCheckpointNumber);
       msg += ` with new checkpoint ${newCheckpointNumber} for epoch ${epochNumber}`;
       this.checkpointNumber = newCheckpointNumber;
       this.checkpointTimestamp = timestamp;
@@ -129,9 +149,9 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
       });
     }
 
-    const newProvenCheckpointNumber = Number(await this.rollup.getProvenCheckpointNumber());
+    const newProvenCheckpointNumber = await this.rollup.getProvenCheckpointNumber();
     if (this.provenCheckpointNumber !== newProvenCheckpointNumber) {
-      const epochNumber = await this.rollup.getEpochNumberForCheckpoint(BigInt(newProvenCheckpointNumber));
+      const epochNumber = await this.rollup.getEpochNumberForCheckpoint(newProvenCheckpointNumber);
       msg += ` with proof up to checkpoint ${newProvenCheckpointNumber} for epoch ${epochNumber}`;
       this.provenCheckpointNumber = newProvenCheckpointNumber;
       this.provenCheckpointTimestamp = timestamp;
@@ -153,9 +173,9 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
     let committee: EthAddress[] | undefined;
     if (l2Epoch !== this.l2EpochNumber) {
       this.l2EpochNumber = l2Epoch;
-      committee = (await this.rollup.getCurrentEpochCommittee())?.map(addr => EthAddress.fromString(addr));
+      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) {
@@ -163,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,
@@ -173,6 +200,7 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
       provenCheckpointNumber: this.provenCheckpointNumber,
       totalL2Messages: this.totalL2Messages,
       committee,
+      ...this.l2FeeData,
     });
 
     return this;
@@ -225,14 +253,13 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
     });
   }
 
-  public waitUntilCheckpoint(checkpointNumber: number | bigint): Promise<void> {
-    const targetBlock = typeof checkpointNumber === 'bigint' ? checkpointNumber.valueOf() : checkpointNumber;
-    if (this.checkpointNumber >= targetBlock) {
+  public waitUntilCheckpoint(checkpointNumber: CheckpointNumber): Promise<void> {
+    if (this.checkpointNumber >= checkpointNumber) {
       return Promise.resolve();
     }
     return new Promise(resolve => {
-      const listener = (data: { checkpointNumber: number; timestamp: bigint }) => {
-        if (data.checkpointNumber >= targetBlock) {
+      const listener = (data: { checkpointNumber: CheckpointNumber; timestamp: bigint }) => {
+        if (data.checkpointNumber >= checkpointNumber) {
           this.off('checkpoint', listener);
           resolve();
         }
@@ -240,4 +267,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
+    );
+  }
 }