@aztec/ethereum 3.0.0-nightly.20250911 → 3.0.0-nightly.20250912

package/dest/utils.js

@@ -118,34 +118,16 @@ function getNestedErrorData(error) {
     if (error instanceof Error) {
         return new FormattedViemError(error.message, error?.metaMessages);
     }
-    // Extract the actual error message and highlight it for clarity
-    let formattedRes = extractAndFormatRequestBody(error?.message || String(error));
-    let errorDetail = '';
-    // Look for specific details in known locations
-    if (error) {
-        // Check for details property which often has the most specific error message
-        if (typeof error.details === 'string' && error.details) {
-            errorDetail = error.details;
-        } else if (typeof error.shortMessage === 'string' && error.shortMessage) {
-            errorDetail = error.shortMessage;
-        }
-    }
-    // If we found a specific error detail, format it clearly
-    if (errorDetail) {
-        // Look for key sections of the formatted result to replace with highlighted error
-        let replaced = false;
-        // Try to find the Details: section
-        const detailsMatch = formattedRes.match(/Details: ([^\n]+)/);
-        if (detailsMatch) {
-            formattedRes = formattedRes.replace(detailsMatch[0], `Details: *${errorDetail}*`);
-            replaced = true;
-        }
-        // If we didn't find a Details section, add the error at the beginning
-        if (!replaced) {
-            formattedRes = `Error: *${errorDetail}*\n\n${formattedRes}`;
-        }
-    }
-    return new FormattedViemError(formattedRes.replace(/\\n/g, '\n'), error?.metaMessages);
+    const body = String(error);
+    const length = body.length;
+    // LogExplorer can only render up to 2500 characters in it's summary view. Try to keep the whole message below this number
+    // Limit the error to 2000 chacaters in order to allow code higher up to decorate this error with extra details (up to 500 characters)
+    if (length > 2000) {
+        const chunk = 950;
+        const truncated = length - 2 * chunk;
+        return new FormattedViemError(body.slice(0, chunk) + `...${truncated} characters truncated...` + body.slice(-1 * chunk));
+    }
+    return new FormattedViemError(body);
 }
 function stripAbis(obj) {
     if (!obj || typeof obj !== 'object') {
@@ -166,139 +148,6 @@ function stripAbis(obj) {
         }
     });
 }
-function extractAndFormatRequestBody(message) {
-    // First check if message is extremely large and contains very large hex strings
-    if (message.length > 50000) {
-        message = replaceHexStrings(message, {
-            minLength: 10000,
-            truncateLength: 200
-        });
-    }
-    // Add a specific check for RPC calls with large params
-    if (message.includes('"method":"eth_sendRawTransaction"')) {
-        message = replaceHexStrings(message, {
-            pattern: /"params":\s*\[\s*"(0x[a-fA-F0-9]{1000,})"\s*\]/g,
-            transform: (hex)=>`"params":["${truncateHex(hex, 200)}"]`
-        });
-    }
-    // First handle Request body JSON
-    const requestBodyRegex = /Request body: ({[\s\S]*?})\n/g;
-    let result = message.replace(requestBodyRegex, (match, body)=>{
-        return `Request body: ${formatRequestBody(body)}\n`;
-    });
-    // Then handle Arguments section
-    const argsRegex = /((?:Request |Estimate Gas )?Arguments:[\s\S]*?(?=\n\n|$))/g;
-    result = result.replace(argsRegex, (section)=>{
-        const lines = section.split('\n');
-        const processedLines = lines.map((line)=>{
-            // Check if line contains a colon followed by content
-            const colonIndex = line.indexOf(':');
-            if (colonIndex !== -1) {
-                const [prefix, content] = [
-                    line.slice(0, colonIndex + 1),
-                    line.slice(colonIndex + 1).trim()
-                ];
-                // If content contains a hex string, truncate it
-                if (content.includes('0x')) {
-                    const processedContent = replaceHexStrings(content);
-                    return `${prefix} ${processedContent}`;
-                }
-            }
-            return line;
-        });
-        return processedLines.join('\n');
-    });
-    // Finally, catch any remaining hex strings in the message
-    result = replaceHexStrings(result);
-    return result;
-}
-function truncateHex(hex, length = 100) {
-    if (!hex || typeof hex !== 'string') {
-        return hex;
-    }
-    if (!hex.startsWith('0x')) {
-        return hex;
-    }
-    if (hex.length <= length * 2) {
-        return hex;
-    }
-    // For extremely large hex strings, use more aggressive truncation
-    if (hex.length > 10000) {
-        return `${hex.slice(0, length)}...<${hex.length - length * 2} chars omitted>...${hex.slice(-length)}`;
-    }
-    return `${hex.slice(0, length)}...${hex.slice(-length)}`;
-}
-function replaceHexStrings(text, options = {}) {
-    const { minLength = 10, maxLength = Infinity, truncateLength = 100, pattern, transform = (hex)=>truncateHex(hex, truncateLength) } = options;
-    const hexRegex = pattern ?? new RegExp(`(0x[a-fA-F0-9]{${minLength},${maxLength}})`, 'g');
-    return text.replace(hexRegex, (match)=>transform(match));
-}
-function formatRequestBody(body) {
-    try {
-        // Special handling for eth_sendRawTransaction
-        if (body.includes('"method":"eth_sendRawTransaction"')) {
-            try {
-                const parsed = JSON.parse(body);
-                if (parsed.params && Array.isArray(parsed.params) && parsed.params.length > 0) {
-                    // These are likely large transaction hex strings
-                    parsed.params = parsed.params.map((param)=>{
-                        if (typeof param === 'string' && param.startsWith('0x') && param.length > 1000) {
-                            return truncateHex(param, 200);
-                        }
-                        return param;
-                    });
-                }
-                return JSON.stringify(parsed, null, 2);
-            } catch  {
-                // If specific parsing fails, fall back to regex-based truncation
-                return replaceHexStrings(body, {
-                    pattern: /"params":\s*\[\s*"(0x[a-fA-F0-9]{1000,})"\s*\]/g,
-                    transform: (hex)=>`"params":["${truncateHex(hex, 200)}"]`
-                });
-            }
-        }
-        // For extremely large request bodies, use simple truncation instead of parsing
-        if (body.length > 50000) {
-            const jsonStart = body.indexOf('{');
-            const jsonEnd = body.lastIndexOf('}');
-            if (jsonStart >= 0 && jsonEnd > jsonStart) {
-                return replaceHexStrings(body, {
-                    minLength: 10000,
-                    truncateLength: 200
-                });
-            }
-        }
-        const parsed = JSON.parse(body);
-        // Process the entire request body
-        const processed = processParams(parsed);
-        return JSON.stringify(processed, null, 2);
-    } catch  {
-        // If JSON parsing fails, do a simple truncation of any large hex strings
-        return replaceHexStrings(body, {
-            minLength: 1000,
-            truncateLength: 150
-        });
-    }
-}
-// Recursively process all parameters that might contain hex strings
-function processParams(obj) {
-    if (Array.isArray(obj)) {
-        return obj.map((item)=>processParams(item));
-    }
-    if (typeof obj === 'object' && obj !== null) {
-        const result = {};
-        for (const [key, value] of Object.entries(obj)){
-            result[key] = processParams(value);
-        }
-        return result;
-    }
-    if (typeof obj === 'string') {
-        if (obj.startsWith('0x')) {
-            return truncateHex(obj);
-        }
-    }
-    return obj;
-}
 export function tryGetCustomErrorName(err) {
     try {
         // See https://viem.sh/docs/contract/simulateContract#handling-custom-errors

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/ethereum",
-  "version": "3.0.0-nightly.20250911",
+  "version": "3.0.0-nightly.20250912",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -31,10 +31,10 @@
     "../package.common.json"
   ],
   "dependencies": {
-    "@aztec/blob-lib": "3.0.0-nightly.20250911",
-    "@aztec/constants": "3.0.0-nightly.20250911",
-    "@aztec/foundation": "3.0.0-nightly.20250911",
-    "@aztec/l1-artifacts": "3.0.0-nightly.20250911",
+    "@aztec/blob-lib": "3.0.0-nightly.20250912",
+    "@aztec/constants": "3.0.0-nightly.20250912",
+    "@aztec/foundation": "3.0.0-nightly.20250912",
+    "@aztec/l1-artifacts": "3.0.0-nightly.20250912",
     "@viem/anvil": "^0.0.10",
     "dotenv": "^16.0.3",
     "lodash.chunk": "^4.2.0",

package/src/config.ts

@@ -28,6 +28,8 @@ export type L1ContractsConfig = {
   aztecEpochDuration: number;
   /** The target validator committee size. */
   aztecTargetCommitteeSize: number;
+  /** The number of epochs to lag behind the current epoch for validator selection. */
+  lagInEpochs: number;
   /** The number of epochs after an epoch ends that proofs are still accepted. */
   aztecProofSubmissionEpochs: number;
   /** The deposit amount for a validator */
@@ -73,6 +75,7 @@ export const DefaultL1ContractsConfig = {
   aztecSlotDuration: 36,
   aztecEpochDuration: 32,
   aztecTargetCommitteeSize: 48,
+  lagInEpochs: 2,
   aztecProofSubmissionEpochs: 1, // you have a full epoch to submit a proof after the epoch to prove ends
   activationThreshold: BigInt(100e18),
   ejectionThreshold: BigInt(50e18),
@@ -303,6 +306,11 @@ export const l1ContractsConfigMappings: ConfigMappingsType<L1ContractsConfig> =
     description: 'The target validator committee size.',
     ...numberConfigHelper(DefaultL1ContractsConfig.aztecTargetCommitteeSize),
   },
+  lagInEpochs: {
+    env: 'AZTEC_LAG_IN_EPOCHS',
+    description: 'The number of epochs to lag behind the current epoch for validator selection.',
+    ...numberConfigHelper(DefaultL1ContractsConfig.lagInEpochs),
+  },
   aztecProofSubmissionEpochs: {
     env: 'AZTEC_PROOF_SUBMISSION_EPOCHS',
     description: 'The number of epochs after an epoch ends that proofs are still accepted.',

package/src/contracts/rollup.ts

@@ -10,6 +10,7 @@ import {
   type GetContractReturnType,
   type Hex,
   type StateOverride,
+  type WatchContractEventReturnType,
   encodeFunctionData,
   getContract,
   hexToBigInt,
@@ -225,6 +226,11 @@ export class RollupContract {
     return this.rollup.read.getLocalEjectionThreshold();
   }
 
+  @memoize
+  getLagInEpochs() {
+    return this.rollup.read.getLagInEpochs();
+  }
+
   @memoize
   getActivationThreshold() {
     return this.rollup.read.getActivationThreshold();
@@ -436,8 +442,15 @@ export class RollupContract {
     return this.rollup.read.getEntryQueueLength();
   }
 
-  async getEpochNumber(blockNumber?: bigint) {
-    blockNumber ??= await this.getBlockNumber();
+  getNextFlushableEpoch() {
+    return this.rollup.read.getNextFlushableEpoch();
+  }
+
+  getCurrentEpochNumber(): Promise<bigint> {
+    return this.rollup.read.getCurrentEpoch();
+  }
+
+  getEpochNumberForBlock(blockNumber: bigint) {
     return this.rollup.read.getEpochForBlock([BigInt(blockNumber)]);
   }
 
@@ -722,7 +735,9 @@ export class RollupContract {
     });
   }
 
-  public listenToSlasherChanged(callback: (args: { oldSlasher: `0x${string}`; newSlasher: `0x${string}` }) => unknown) {
+  public listenToSlasherChanged(
+    callback: (args: { oldSlasher: `0x${string}`; newSlasher: `0x${string}` }) => unknown,
+  ): WatchContractEventReturnType {
     return this.rollup.watchEvent.SlasherUpdated(
       {},
       {
@@ -738,6 +753,22 @@ export class RollupContract {
     );
   }
 
+  public listenToBlockInvalidated(callback: (args: { blockNumber: bigint }) => unknown): WatchContractEventReturnType {
+    return this.rollup.watchEvent.BlockInvalidated(
+      {},
+      {
+        onLogs: logs => {
+          for (const log of logs) {
+            const args = log.args;
+            if (args.blockNumber !== undefined) {
+              callback({ blockNumber: args.blockNumber });
+            }
+          }
+        },
+      },
+    );
+  }
+
   public async getSlashEvents(l1BlockHash: Hex): Promise<{ amount: bigint; attester: EthAddress }[]> {
     const events = await this.rollup.getEvents.Slashed({}, { blockHash: l1BlockHash, strict: true });
     return events.map(event => ({
@@ -746,7 +777,9 @@ export class RollupContract {
     }));
   }
 
-  public listenToSlash(callback: (args: { amount: bigint; attester: EthAddress }) => unknown) {
+  public listenToSlash(
+    callback: (args: { amount: bigint; attester: EthAddress }) => unknown,
+  ): WatchContractEventReturnType {
     return this.rollup.watchEvent.Slashed(
       {},
       {

package/src/deploy_l1_contracts.ts

@@ -5,6 +5,7 @@ import { EthAddress } from '@aztec/foundation/eth-address';
 import type { Fr } from '@aztec/foundation/fields';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 import { type Logger, createLogger } from '@aztec/foundation/log';
+import { retryUntil } from '@aztec/foundation/retry';
 import { DateProvider } from '@aztec/foundation/timer';
 import type { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
 
@@ -430,6 +431,7 @@ export const deployRollupForUpgrade = async (
   registryAddress: EthAddress,
   logger: Logger,
   txUtilsConfig: L1TxUtilsConfig,
+  flushEntryQueue: boolean = true,
 ) => {
   const deployer = new L1Deployer(
     extendedClient,
@@ -442,7 +444,14 @@ export const deployRollupForUpgrade = async (
 
   const addresses = await RegistryContract.collectAddresses(extendedClient, registryAddress, 'canonical');
 
-  const { rollup, slashFactoryAddress } = await deployRollup(extendedClient, deployer, args, addresses, logger);
+  const { rollup, slashFactoryAddress } = await deployRollup(
+    extendedClient,
+    deployer,
+    args,
+    addresses,
+    flushEntryQueue,
+    logger,
+  );
 
   await deployer.waitForDeployments();
 
@@ -501,6 +510,7 @@ export const deployRollup = async (
     | 'gseAddress'
     | 'governanceAddress'
   >,
+  flushEntryQueue: boolean,
   logger: Logger,
 ) => {
   if (!addresses.gseAddress) {
@@ -530,6 +540,7 @@ export const deployRollup = async (
     aztecSlotDuration: BigInt(args.aztecSlotDuration),
     aztecEpochDuration: BigInt(args.aztecEpochDuration),
     targetCommitteeSize: BigInt(args.aztecTargetCommitteeSize),
+    lagInEpochs: BigInt(args.lagInEpochs),
     aztecProofSubmissionEpochs: BigInt(args.aztecProofSubmissionEpochs),
     slashingQuorum: BigInt(args.slashingQuorum ?? (args.slashingRoundSizeInEpochs * args.aztecEpochDuration) / 2 + 1),
     slashingRoundSize: BigInt(args.slashingRoundSizeInEpochs * args.aztecEpochDuration),
@@ -674,6 +685,7 @@ export const deployRollup = async (
       addresses.stakingAssetAddress.toString(),
       args.initialValidators,
       args.acceleratedTestDeployments,
+      flushEntryQueue,
       logger,
     );
   }
@@ -850,6 +862,7 @@ export const addMultipleValidators = async (
   stakingAssetAddress: Hex,
   validators: Operator[],
   acceleratedTestDeployments: boolean | undefined,
+  flushEntryQueue: boolean,
   logger: Logger,
 ) => {
   const rollup = new RollupContract(extendedClient, rollupAddress);
@@ -916,7 +929,7 @@ export const addMultipleValidators = async (
             data: encodeFunctionData({
               abi: MultiAdderArtifact.contractAbi,
               functionName: 'addValidators',
-              args: [validatorsTuples, true],
+              args: [validatorsTuples, /* skip flushing */ true],
             }),
           },
           {
@@ -924,19 +937,49 @@ export const addMultipleValidators = async (
           },
         );
 
-        await deployer.l1TxUtils.sendAndMonitorTransaction(
-          {
-            to: rollupAddress,
-            data: encodeFunctionData({
-              abi: RollupArtifact.contractAbi,
-              functionName: 'flushEntryQueue',
-              args: [],
-            }),
-          },
-          {
-            gasLimit: 40_000_000n,
-          },
-        );
+        let queueLength = await rollup.getEntryQueueLength();
+        while (flushEntryQueue && queueLength > 0n) {
+          logger.info(`Flushing entry queue with ${queueLength} entries`);
+
+          try {
+            await deployer.l1TxUtils.sendAndMonitorTransaction(
+              {
+                to: rollupAddress,
+                data: encodeFunctionData({
+                  abi: RollupArtifact.contractAbi,
+                  functionName: 'flushEntryQueue',
+                  args: [],
+                }),
+              },
+              {
+                gasLimit: 20_000_000n,
+              },
+            );
+          } catch (err) {
+            logger.warn('Failed to flush queue', { err });
+          }
+
+          queueLength = await rollup.getEntryQueueLength();
+          // check if we drained the queue enough here so we can avoid sleep
+          if (queueLength === 0n) {
+            break;
+          }
+
+          logger.info(`Waiting for next flushable epoch to flush remaining ${queueLength} entries`);
+          await retryUntil(
+            async () => {
+              const [currentEpoch, flushableEpoch] = await Promise.all([
+                rollup.getCurrentEpochNumber(),
+                rollup.getNextFlushableEpoch(),
+              ]);
+              logger.debug(`Next flushable epoch is ${flushableEpoch} (current epoch is ${currentEpoch})`);
+              return currentEpoch >= flushableEpoch;
+            },
+            'wait for next flushable epoch',
+            3600,
+            12,
+          );
+        }
       } else {
         await deployer.l1TxUtils.sendAndMonitorTransaction(
           {
@@ -944,7 +987,7 @@ export const addMultipleValidators = async (
             data: encodeFunctionData({
               abi: MultiAdderArtifact.contractAbi,
               functionName: 'addValidators',
-              args: [validatorsTuples, false],
+              args: [validatorsTuples, /* skip flushing */ !flushEntryQueue],
             }),
           },
           {
@@ -1027,6 +1070,7 @@ export const deployL1Contracts = async (
   args: DeployL1ContractsArgs,
   txUtilsConfig: L1TxUtilsConfig = getL1TxUtilsConfigEnvVars(),
   createVerificationJson: string | false = false,
+  flushEntryQueue: boolean = true,
 ): Promise<DeployL1ContractsReturnType> => {
   logger.info(`Deploying L1 contracts with config: ${jsonStringify(args)}`);
   validateConfig(args);
@@ -1093,6 +1137,7 @@ export const deployL1Contracts = async (
       stakingAssetAddress,
       governanceAddress,
     },
+    flushEntryQueue,
     logger,
   );
 

package/src/l1_tx_utils.ts

@@ -279,7 +279,13 @@ export class ReadOnlyL1TxUtils {
     let blobBaseFee = 0n;
     if (isBlobTx) {
       try {
-        blobBaseFee = await this.client.getBlobBaseFee();
+        blobBaseFee = await retry<bigint>(
+          () => this.client.getBlobBaseFee(),
+          'Getting L1 blob base fee',
+          makeBackoff(times(2, () => 1)),
+          this.logger,
+          true,
+        );
         this.logger?.debug('L1 Blob base fee:', { blobBaseFee: formatGwei(blobBaseFee) });
       } catch {
         this.logger?.warn('Failed to get L1 blob base fee', attempt);
@@ -864,7 +870,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
             },
           );
 
-          const txData = {
+          const txData: PrepareTransactionRequestRequest = {
             ...request,
             ...blobInputs,
             nonce,
@@ -872,6 +878,9 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
             maxFeePerGas: newGasPrice.maxFeePerGas,
             maxPriorityFeePerGas: newGasPrice.maxPriorityFeePerGas,
           };
+          if (isBlobTx && newGasPrice.maxFeePerBlobGas) {
+            (txData as any).maxFeePerBlobGas = newGasPrice.maxFeePerBlobGas;
+          }
           const signedRequest = await this.prepareSignedTransaction(txData);
           const newHash = await this.client.sendRawTransaction({ serializedTransaction: signedRequest });
           if (!isCancelTx) {

package/src/queries.ts

@@ -33,6 +33,7 @@ export async function getL1ContractsConfig(
     aztecSlotDuration,
     aztecProofSubmissionEpochs,
     aztecTargetCommitteeSize,
+    lagInEpochs,
     activationThreshold,
     ejectionThreshold,
     localEjectionThreshold,
@@ -57,6 +58,7 @@ export async function getL1ContractsConfig(
     rollup.getSlotDuration(),
     rollup.getProofSubmissionEpochs(),
     rollup.getTargetCommitteeSize(),
+    rollup.getLagInEpochs(),
     rollup.getActivationThreshold(),
     rollup.getEjectionThreshold(),
     rollup.getLocalEjectionThreshold(),
@@ -83,6 +85,7 @@ export async function getL1ContractsConfig(
     aztecSlotDuration: Number(aztecSlotDuration),
     aztecProofSubmissionEpochs: Number(aztecProofSubmissionEpochs),
     aztecTargetCommitteeSize: Number(aztecTargetCommitteeSize),
+    lagInEpochs: Number(lagInEpochs),
     governanceProposerQuorum: Number(governanceProposerQuorum),
     governanceProposerRoundSize: Number(governanceProposerRoundSize),
     activationThreshold,

package/src/test/chain_monitor.ts

@@ -10,7 +10,7 @@ import type { ViemClient } from '../types.js';
 
 export type ChainMonitorEventMap = {
   'l1-block': [{ l1BlockNumber: number; timestamp: bigint }];
-  'l2-block': [{ l2BlockNumber: number; l1BlockNumber: number; timestamp: bigint }];
+  'l2-block': [{ l2BlockNumber: number; l1BlockNumber: number; l2SlotNumber: number; timestamp: bigint }];
   'l2-block-proven': [{ l2ProvenBlockNumber: number; l1BlockNumber: number; timestamp: bigint }];
   'l2-messages': [{ totalL2Messages: number; l1BlockNumber: number }];
   'l2-epoch': [{ l2EpochNumber: number; timestamp: bigint; committee: EthAddress[] | undefined }];
@@ -102,8 +102,13 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
     }
     this.l1BlockNumber = newL1BlockNumber;
 
-    const block = await this.l1Client.getBlock({ blockNumber: BigInt(newL1BlockNumber), includeTransactions: false });
-    const timestamp = block.timestamp;
+    const [l2SlotNumber, l2Epoch, l1block] = await Promise.all([
+      this.rollup.getSlotNumber(),
+      this.rollup.getCurrentEpoch(),
+      this.l1Client.getBlock({ blockNumber: BigInt(newL1BlockNumber), includeTransactions: false }),
+    ]);
+
+    const timestamp = l1block.timestamp;
     const timestampString = new Date(Number(timestamp) * 1000).toTimeString().split(' ')[0];
 
     this.emit('l1-block', { l1BlockNumber: newL1BlockNumber, timestamp });
@@ -111,16 +116,21 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
 
     const newL2BlockNumber = Number(await this.rollup.getBlockNumber());
     if (this.l2BlockNumber !== newL2BlockNumber) {
-      const epochNumber = await this.rollup.getEpochNumber(BigInt(newL2BlockNumber));
+      const epochNumber = await this.rollup.getEpochNumberForBlock(BigInt(newL2BlockNumber));
       msg += ` with new L2 block ${newL2BlockNumber} for epoch ${epochNumber}`;
       this.l2BlockNumber = newL2BlockNumber;
       this.l2BlockTimestamp = timestamp;
-      this.emit('l2-block', { l2BlockNumber: newL2BlockNumber, l1BlockNumber: newL1BlockNumber, timestamp });
+      this.emit('l2-block', {
+        l2BlockNumber: newL2BlockNumber,
+        l1BlockNumber: newL1BlockNumber,
+        l2SlotNumber: Number(l2SlotNumber),
+        timestamp,
+      });
     }
 
     const newL2ProvenBlockNumber = Number(await this.rollup.getProvenBlockNumber());
     if (this.l2ProvenBlockNumber !== newL2ProvenBlockNumber) {
-      const epochNumber = await this.rollup.getEpochNumber(BigInt(newL2ProvenBlockNumber));
+      const epochNumber = await this.rollup.getEpochNumberForBlock(BigInt(newL2ProvenBlockNumber));
       msg += ` with proof up to L2 block ${newL2ProvenBlockNumber} for epoch ${epochNumber}`;
       this.l2ProvenBlockNumber = newL2ProvenBlockNumber;
       this.l2ProvenBlockTimestamp = timestamp;
@@ -139,8 +149,6 @@ 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()]);
-
     let committee: EthAddress[] | undefined;
     if (l2Epoch !== this.l2EpochNumber) {
       this.l2EpochNumber = l2Epoch;
@@ -184,4 +192,52 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
       this.on('l2-slot', listener);
     });
   }
+
+  public waitUntilL1Block(block: number | bigint): Promise<void> {
+    const targetBlock = typeof block === 'bigint' ? block.valueOf() : block;
+    if (this.l1BlockNumber >= targetBlock) {
+      return Promise.resolve();
+    }
+    return new Promise(resolve => {
+      const listener = (data: { l1BlockNumber: number; timestamp: bigint }) => {
+        if (data.l1BlockNumber >= targetBlock) {
+          this.off('l1-block', listener);
+          resolve();
+        }
+      };
+      this.on('l1-block', listener);
+    });
+  }
+
+  public waitUntilL1Timestamp(timestamp: number | bigint): Promise<void> {
+    const targetTimestamp = typeof timestamp === 'bigint' ? timestamp.valueOf() : timestamp;
+    if (this.l1BlockNumber >= targetTimestamp) {
+      return Promise.resolve();
+    }
+    return new Promise(resolve => {
+      const listener = (data: { l1BlockNumber: number; timestamp: bigint }) => {
+        if (data.timestamp >= targetTimestamp) {
+          this.off('l1-block', listener);
+          resolve();
+        }
+      };
+      this.on('l1-block', listener);
+    });
+  }
+
+  public waitUntilL2Block(l2BlockNumber: number | bigint): Promise<void> {
+    const targetBlock = typeof l2BlockNumber === 'bigint' ? l2BlockNumber.valueOf() : l2BlockNumber;
+    if (this.l2BlockNumber >= targetBlock) {
+      return Promise.resolve();
+    }
+    return new Promise(resolve => {
+      const listener = (data: { l2BlockNumber: number; timestamp: bigint }) => {
+        if (data.l2BlockNumber >= targetBlock) {
+          this.off('l2-block', listener);
+          resolve();
+        }
+      };
+      this.on('l2-block', listener);
+    });
+  }
 }