@aztec/ethereum 3.0.0-devnet.2 → 3.0.0-devnet.20251212

package/src/l1_tx_utils/readonly_l1_tx_utils.ts

@@ -1,4 +1,4 @@
-import { getKeys, merge, pick, times } from '@aztec/foundation/collection';
+import { getKeys, median, merge, pick, times } from '@aztec/foundation/collection';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { makeBackoff, retry } from '@aztec/foundation/retry';
 import { DateProvider } from '@aztec/foundation/timer';
@@ -33,6 +33,8 @@ import {
 import type { GasPrice, L1BlobInputs, L1TxRequest, TransactionStats } from './types.js';
 import { getCalldataGasUsage, tryGetCustomErrorNameContractFunction } from './utils.js';
 
+const HISTORICAL_BLOCK_COUNT = 5;
+
 export class ReadOnlyL1TxUtils {
   public config: Required<L1TxUtilsConfig>;
   protected interrupted = false;
@@ -63,6 +65,124 @@ export class ReadOnlyL1TxUtils {
     return this.client.getBlockNumber();
   }
 
+  /**
+   * Analyzes pending transactions and recent fee history to determine a competitive priority fee.
+   * Falls back to network estimate if data is unavailable or fails.
+   * @param networkEstimateResult - Result from estimateMaxPriorityFeePerGas RPC call
+   * @param pendingBlockResult - Result from getBlock with pending tag RPC call
+   * @param feeHistoryResult - Result from getFeeHistory RPC call
+   * @returns A competitive priority fee based on pending txs and recent block history
+   */
+  protected getCompetitivePriorityFee(
+    networkEstimateResult: PromiseSettledResult<bigint | null>,
+    pendingBlockResult: PromiseSettledResult<Awaited<ReturnType<ViemClient['getBlock']>> | null>,
+    feeHistoryResult: PromiseSettledResult<Awaited<ReturnType<ViemClient['getFeeHistory']>> | null>,
+  ): bigint {
+    const networkEstimate =
+      networkEstimateResult.status === 'fulfilled' && typeof networkEstimateResult.value === 'bigint'
+        ? networkEstimateResult.value
+        : 0n;
+    let competitiveFee = networkEstimate;
+
+    if (
+      pendingBlockResult.status === 'fulfilled' &&
+      pendingBlockResult.value !== null &&
+      pendingBlockResult.value.transactions &&
+      pendingBlockResult.value.transactions.length > 0
+    ) {
+      const pendingBlock = pendingBlockResult.value;
+      // Extract priority fees from pending transactions
+      const pendingFees = pendingBlock.transactions
+        .map(tx => {
+          // Transaction can be just a hash string, so we need to check if it's an object
+          if (typeof tx === 'string') {
+            return 0n;
+          }
+          const fee = tx.maxPriorityFeePerGas || 0n;
+          // Debug: Log suspicious fees
+          if (fee > 100n * WEI_CONST) {
+            this.logger?.warn('Suspicious high priority fee in pending tx', {
+              txHash: tx.hash,
+              maxPriorityFeePerGas: formatGwei(fee),
+              maxFeePerGas: formatGwei(tx.maxFeePerGas || 0n),
+              maxFeePerBlobGas: tx.maxFeePerBlobGas ? formatGwei(tx.maxFeePerBlobGas) : 'N/A',
+            });
+          }
+          return fee;
+        })
+        .filter((fee: bigint) => fee > 0n);
+
+      if (pendingFees.length > 0) {
+        // Use 75th percentile of pending fees to be competitive
+        const sortedPendingFees = [...pendingFees].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+        const percentile75Index = Math.floor((sortedPendingFees.length - 1) * 0.75);
+        const pendingCompetitiveFee = sortedPendingFees[percentile75Index];
+
+        if (pendingCompetitiveFee > competitiveFee) {
+          competitiveFee = pendingCompetitiveFee;
+        }
+
+        this.logger?.debug('Analyzed pending transactions for competitive pricing', {
+          pendingTxCount: pendingFees.length,
+          pendingP75: formatGwei(pendingCompetitiveFee),
+        });
+      }
+    }
+    if (
+      feeHistoryResult.status === 'fulfilled' &&
+      feeHistoryResult.value !== null &&
+      feeHistoryResult.value.reward &&
+      feeHistoryResult.value.reward.length > 0
+    ) {
+      const feeHistory = feeHistoryResult.value;
+      // Extract 75th percentile fees from each block
+      const percentile75Fees = feeHistory.reward!.map(rewards => rewards[0] || 0n).filter(fee => fee > 0n);
+
+      if (percentile75Fees.length > 0) {
+        // Calculate median of the 75th percentile fees across blocks
+        const medianHistoricalFee = median(percentile75Fees) ?? 0n;
+
+        // Debug: Log suspicious fees from history
+        if (medianHistoricalFee > 100n * WEI_CONST) {
+          this.logger?.warn('Suspicious high fee in history', {
+            historicalMedian: formatGwei(medianHistoricalFee),
+            allP75Fees: percentile75Fees.map(f => formatGwei(f)),
+          });
+        }
+
+        if (medianHistoricalFee > competitiveFee) {
+          competitiveFee = medianHistoricalFee;
+        }
+
+        this.logger?.debug('Analyzed fee history for competitive pricing', {
+          historicalMedian: formatGwei(medianHistoricalFee),
+        });
+      }
+    }
+
+    // Sanity check: cap competitive fee at 100x network estimate to avoid using unrealistic fees
+    // (e.g., Anvil returns inflated historical fees that don't reflect actual network conditions)
+    const maxReasonableFee = networkEstimate * 100n;
+    if (competitiveFee > maxReasonableFee) {
+      this.logger?.warn('Competitive fee exceeds sanity cap, using capped value', {
+        competitiveFee: formatGwei(competitiveFee),
+        networkEstimate: formatGwei(networkEstimate),
+        cappedTo: formatGwei(maxReasonableFee),
+      });
+      competitiveFee = maxReasonableFee;
+    }
+
+    // Log final decision
+    if (competitiveFee > networkEstimate) {
+      this.logger?.debug('Using competitive fee from market analysis', {
+        networkEstimate: formatGwei(networkEstimate),
+        competitive: formatGwei(competitiveFee),
+      });
+    }
+
+    return competitiveFee;
+  }
+
   /**
    * Gets the current gas price with bounds checking
    */
@@ -73,35 +193,71 @@ export class ReadOnlyL1TxUtils {
     previousGasPrice?: typeof attempt extends 0 ? never : GasPrice,
   ): Promise<GasPrice> {
     const gasConfig = merge(this.config, gasConfigOverrides);
-    const block = await this.client.getBlock({ blockTag: 'latest' });
-    const baseFee = block.baseFeePerGas ?? 0n;
+
+    // Make all RPC calls in parallel upfront with retry logic
+    const latestBlockPromise = this.tryTwice(
+      () => this.client.getBlock({ blockTag: 'latest' }),
+      'Getting latest block',
+    );
+    const networkEstimatePromise = this.tryTwice(
+      () => this.client.estimateMaxPriorityFeePerGas(),
+      'Estimating max priority fee per gas',
+    );
+    const pendingBlockPromise = this.tryTwice(
+      () => this.client.getBlock({ blockTag: 'pending', includeTransactions: true }),
+      'Getting pending block',
+    );
+    const feeHistoryPromise = this.tryTwice(
+      () => this.client.getFeeHistory({ blockCount: HISTORICAL_BLOCK_COUNT, rewardPercentiles: [75] }),
+      'Getting fee history',
+    );
+    const blobBaseFeePromise = isBlobTx
+      ? this.tryTwice(() => this.client.getBlobBaseFee(), 'Getting blob base fee')
+      : null;
+
+    const [latestBlockResult, networkEstimateResult, pendingBlockResult, feeHistoryResult, blobBaseFeeResult] =
+      await Promise.allSettled([
+        latestBlockPromise,
+        networkEstimatePromise,
+        pendingBlockPromise,
+        feeHistoryPromise,
+        blobBaseFeePromise ?? Promise.resolve(0n),
+      ]);
+
+    // Extract results
+    const baseFee =
+      latestBlockResult.status === 'fulfilled' &&
+      typeof latestBlockResult.value === 'object' &&
+      latestBlockResult.value.baseFeePerGas
+        ? latestBlockResult.value.baseFeePerGas
+        : 0n;
 
     // Get blob base fee if available
     let blobBaseFee = 0n;
-    if (isBlobTx) {
-      try {
-        blobBaseFee = await retry<bigint>(
-          () => this.client.getBlobBaseFee(),
-          'Getting L1 blob base fee',
-          makeBackoff(times(2, () => 1)),
-          this.logger,
-          true,
-        );
-      } catch {
-        this.logger?.warn('Failed to get L1 blob base fee', attempt);
-      }
+    if (isBlobTx && blobBaseFeeResult.status === 'fulfilled' && typeof blobBaseFeeResult.value === 'bigint') {
+      blobBaseFee = blobBaseFeeResult.value;
+    } else if (isBlobTx) {
+      this.logger?.warn('Failed to get L1 blob base fee', attempt);
     }
 
-    let priorityFee: bigint;
-    if (gasConfig.fixedPriorityFeePerGas) {
-      this.logger?.debug('Using fixed priority fee per L1 gas', {
-        fixedPriorityFeePerGas: gasConfig.fixedPriorityFeePerGas,
-      });
-      // try to maintain precision up to 1000000 wei
-      priorityFee = BigInt(gasConfig.fixedPriorityFeePerGas * 1_000_000) * (WEI_CONST / 1_000_000n);
-    } else {
-      // Get initial priority fee from the network
-      priorityFee = await this.client.estimateMaxPriorityFeePerGas();
+    // Get competitive priority fee
+    let priorityFee = this.getCompetitivePriorityFee(networkEstimateResult, pendingBlockResult, feeHistoryResult);
+
+    // Apply minimum priority fee as a floor if configured
+    if (gasConfig.minimumPriorityFeePerGas) {
+      const minimumFee = BigInt(Math.trunc(gasConfig.minimumPriorityFeePerGas * Number(WEI_CONST)));
+      if (minimumFee > priorityFee) {
+        this.logger?.debug('Using minimum priority fee as floor', {
+          minimumPriorityFeePerGas: formatGwei(minimumFee),
+          competitiveFee: formatGwei(priorityFee),
+        });
+        priorityFee = minimumFee;
+      } else {
+        this.logger?.debug('Competitive fee exceeds minimum, using competitive fee', {
+          minimumPriorityFeePerGas: formatGwei(minimumFee),
+          competitiveFee: formatGwei(priorityFee),
+        });
+      }
     }
     let maxFeePerGas = baseFee;
 
@@ -115,6 +271,7 @@ export class ReadOnlyL1TxUtils {
       // same for blob gas fee
       maxFeePerBlobGas = (maxFeePerBlobGas * (1_000n + 125n)) / 1_000n;
     }
+
     if (attempt > 0) {
       const configBump =
         gasConfig.priorityFeeRetryBumpPercentage ?? defaultL1TxUtilsConfig.priorityFeeRetryBumpPercentage!;
@@ -129,29 +286,50 @@ export class ReadOnlyL1TxUtils {
         (previousGasPrice!.maxPriorityFeePerGas * (100_00n + BigInt(bumpPercentage * 1_00))) / 100_00n;
       const minMaxFee = (previousGasPrice!.maxFeePerGas * (100_00n + BigInt(bumpPercentage * 1_00))) / 100_00n;
 
-      // Add priority fee to maxFeePerGas
-      maxFeePerGas += priorityFee;
+      // Apply bump percentage to competitive fee
+      const competitivePriorityFee = (priorityFee * (100_00n + BigInt(configBump * 1_00))) / 100_00n;
 
-      // Use maximum between current network values and minimum required values
-      priorityFee = priorityFee > minPriorityFee ? priorityFee : minPriorityFee;
+      this.logger?.debug(`Speed-up attempt ${attempt}: using competitive fee strategy`, {
+        networkEstimate: formatGwei(priorityFee),
+        competitiveFee: formatGwei(competitivePriorityFee),
+        minRequired: formatGwei(minPriorityFee),
+        bumpPercentage: configBump,
+      });
+
+      // Use maximum between competitive fee and minimum required bump
+      const finalPriorityFee = competitivePriorityFee > minPriorityFee ? competitivePriorityFee : minPriorityFee;
+      const feeSource = finalPriorityFee === competitivePriorityFee ? 'competitive' : 'minimum-bump';
+
+      priorityFee = finalPriorityFee;
+      // Add the final priority fee to maxFeePerGas
+      maxFeePerGas += finalPriorityFee;
       maxFeePerGas = maxFeePerGas > minMaxFee ? maxFeePerGas : minMaxFee;
+
+      this.logger?.debug(`Speed-up fee decision: using ${feeSource} fee`, {
+        finalPriorityFee: formatGwei(finalPriorityFee),
+      });
     } else {
-      // first attempt, just bump priority fee, unless it's a fixed config
+      // First attempt: apply configured bump percentage to competitive fee
       // multiply by 100 & divide by 100 to maintain some precision
-      if (!gasConfig.fixedPriorityFeePerGas) {
-        priorityFee = (priorityFee * (100_00n + BigInt((gasConfig.priorityFeeBumpPercentage || 0) * 1_00))) / 100_00n;
-      }
+      priorityFee = (priorityFee * (100_00n + BigInt((gasConfig.priorityFeeBumpPercentage || 0) * 1_00))) / 100_00n;
+      this.logger?.debug('Initial transaction: using competitive fee from market analysis', {
+        networkEstimate: formatGwei(priorityFee),
+      });
       maxFeePerGas += priorityFee;
     }
 
+    // maxGwei and maxBlobGwei are hard limits
+    const effectiveMaxGwei = BigInt(Math.trunc(gasConfig.maxGwei! * Number(WEI_CONST)));
+    const effectiveMaxBlobGwei = BigInt(Math.trunc(gasConfig.maxBlobGwei! * Number(WEI_CONST)));
+
     // Ensure we don't exceed maxGwei
-    const maxGweiInWei = gasConfig.maxGwei! * WEI_CONST;
-    maxFeePerGas = maxFeePerGas > maxGweiInWei ? maxGweiInWei : maxFeePerGas;
+    if (effectiveMaxGwei > 0n) {
+      maxFeePerGas = maxFeePerGas > effectiveMaxGwei ? effectiveMaxGwei : maxFeePerGas;
+    }
 
     // Ensure we don't exceed maxBlobGwei
-    if (maxFeePerBlobGas) {
-      const maxBlobGweiInWei = gasConfig.maxBlobGwei! * WEI_CONST;
-      maxFeePerBlobGas = maxFeePerBlobGas > maxBlobGweiInWei ? maxBlobGweiInWei : maxFeePerBlobGas;
+    if (maxFeePerBlobGas && effectiveMaxBlobGwei > 0n) {
+      maxFeePerBlobGas = maxFeePerBlobGas > effectiveMaxBlobGwei ? effectiveMaxBlobGwei : maxFeePerBlobGas;
     }
 
     // Ensure priority fee doesn't exceed max fee
@@ -369,4 +547,11 @@ export class ReadOnlyL1TxUtils {
     });
     return bumpedGasLimit;
   }
+
+  /**
+   * Helper function to retry RPC calls twice
+   */
+  private tryTwice<T>(fn: () => Promise<T>, description: string): Promise<T> {
+    return retry<T>(fn, description, makeBackoff(times(2, () => 0)), this.logger, true);
+  }
 }

package/src/queries.ts

@@ -33,7 +33,8 @@ export async function getL1ContractsConfig(
     aztecSlotDuration,
     aztecProofSubmissionEpochs,
     aztecTargetCommitteeSize,
-    lagInEpochs,
+    lagInEpochsForValidatorSet,
+    lagInEpochsForRandao,
     activationThreshold,
     ejectionThreshold,
     localEjectionThreshold,
@@ -59,7 +60,8 @@ export async function getL1ContractsConfig(
     rollup.getSlotDuration(),
     rollup.getProofSubmissionEpochs(),
     rollup.getTargetCommitteeSize(),
-    rollup.getLagInEpochs(),
+    rollup.getLagInEpochsForValidatorSet(),
+    rollup.getLagInEpochsForRandao(),
     rollup.getActivationThreshold(),
     rollup.getEjectionThreshold(),
     rollup.getLocalEjectionThreshold(),
@@ -87,7 +89,8 @@ export async function getL1ContractsConfig(
     aztecSlotDuration: Number(aztecSlotDuration),
     aztecProofSubmissionEpochs: Number(aztecProofSubmissionEpochs),
     aztecTargetCommitteeSize: Number(aztecTargetCommitteeSize),
-    lagInEpochs: Number(lagInEpochs),
+    lagInEpochsForValidatorSet: Number(lagInEpochsForValidatorSet),
+    lagInEpochsForRandao: Number(lagInEpochsForRandao),
     governanceProposerQuorum: Number(governanceProposerQuorum),
     governanceProposerRoundSize: Number(governanceProposerRoundSize),
     activationThreshold,

package/src/test/chain_monitor.ts

@@ -1,4 +1,6 @@
-import { InboxContract, type RollupContract } from '@aztec/ethereum/contracts';
+import type { 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';
@@ -10,11 +12,13 @@ import type { ViemClient } from '../types.js';
 
 export type ChainMonitorEventMap = {
   'l1-block': [{ l1BlockNumber: number; timestamp: bigint }];
-  'l2-block': [{ l2BlockNumber: number; l1BlockNumber: number; l2SlotNumber: number; timestamp: bigint }];
-  'l2-block-proven': [{ l2ProvenBlockNumber: 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: number; timestamp: bigint; committee: EthAddress[] | undefined }];
-  'l2-slot': [{ l2SlotNumber: number; timestamp: bigint }];
+  'l2-epoch': [{ l2EpochNumber: EpochNumber; timestamp: bigint; committee: EthAddress[] | undefined }];
+  'l2-slot': [{ l2SlotNumber: SlotNumber; timestamp: bigint }];
 };
 
 /** Utility class that polls the chain on quick intervals and logs new L1 blocks, L2 blocks, and L2 proofs. */
@@ -27,20 +31,20 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
 
   /** Current L1 block number */
   public l1BlockNumber!: number;
-  /** Current L2 block number */
-  public l2BlockNumber!: number;
-  /** Current L2 proven block number */
-  public l2ProvenBlockNumber!: number;
-  /** L1 timestamp for the current L2 block */
-  public l2BlockTimestamp!: bigint;
-  /** L1 timestamp for the proven L2 block */
-  public l2ProvenBlockTimestamp!: bigint;
+  /** Current checkpoint number */
+  public checkpointNumber!: CheckpointNumber;
+  /** Current proven checkpoint number */
+  public provenCheckpointNumber!: CheckpointNumber;
+  /** L1 timestamp for the current checkpoint */
+  public checkpointTimestamp!: bigint;
+  /** L1 timestamp for the proven checkpoint */
+  public provenCheckpointTimestamp!: bigint;
   /** Total number of L2 messages pushed into the Inbox */
   public totalL2Messages: number = 0;
   /** Current L2 epoch number */
-  public l2EpochNumber!: bigint;
+  public l2EpochNumber!: EpochNumber;
   /** Current L2 slot number */
-  public l2SlotNumber!: bigint;
+  public l2SlotNumber!: SlotNumber;
 
   constructor(
     private readonly rollup: RollupContract,
@@ -114,28 +118,28 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
     this.emit('l1-block', { l1BlockNumber: newL1BlockNumber, timestamp });
     let msg = `L1 block ${newL1BlockNumber} mined at ${timestampString}`;
 
-    const newL2BlockNumber = Number(await this.rollup.getBlockNumber());
-    if (this.l2BlockNumber !== 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,
+    const newCheckpointNumber = await this.rollup.getCheckpointNumber();
+    if (this.checkpointNumber !== newCheckpointNumber) {
+      const epochNumber = await this.rollup.getEpochNumberForCheckpoint(newCheckpointNumber);
+      msg += ` with new checkpoint ${newCheckpointNumber} for epoch ${epochNumber}`;
+      this.checkpointNumber = newCheckpointNumber;
+      this.checkpointTimestamp = timestamp;
+      this.emit('checkpoint', {
+        checkpointNumber: newCheckpointNumber,
         l1BlockNumber: newL1BlockNumber,
-        l2SlotNumber: Number(l2SlotNumber),
+        l2SlotNumber,
         timestamp,
       });
     }
 
-    const newL2ProvenBlockNumber = Number(await this.rollup.getProvenBlockNumber());
-    if (this.l2ProvenBlockNumber !== 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;
-      this.emit('l2-block-proven', {
-        l2ProvenBlockNumber: newL2ProvenBlockNumber,
+    const newProvenCheckpointNumber = await this.rollup.getProvenCheckpointNumber();
+    if (this.provenCheckpointNumber !== newProvenCheckpointNumber) {
+      const epochNumber = await this.rollup.getEpochNumberForCheckpoint(newProvenCheckpointNumber);
+      msg += ` with proof up to checkpoint ${newProvenCheckpointNumber} for epoch ${epochNumber}`;
+      this.provenCheckpointNumber = newProvenCheckpointNumber;
+      this.provenCheckpointTimestamp = timestamp;
+      this.emit('checkpoint-proven', {
+        provenCheckpointNumber: newProvenCheckpointNumber,
         l1BlockNumber: newL1BlockNumber,
         timestamp,
       });
@@ -153,13 +157,13 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
     if (l2Epoch !== this.l2EpochNumber) {
       this.l2EpochNumber = l2Epoch;
       committee = (await this.rollup.getCurrentEpochCommittee())?.map(addr => EthAddress.fromString(addr));
-      this.emit('l2-epoch', { l2EpochNumber: Number(l2Epoch), timestamp, committee });
+      this.emit('l2-epoch', { l2EpochNumber: l2Epoch, timestamp, committee });
       msg += ` starting new epoch ${this.l2EpochNumber} `;
     }
 
     if (l2SlotNumber !== this.l2SlotNumber) {
       this.l2SlotNumber = l2SlotNumber;
-      this.emit('l2-slot', { l2SlotNumber: Number(l2SlotNumber), timestamp });
+      this.emit('l2-slot', { l2SlotNumber, timestamp });
     }
 
     this.logger.info(msg, {
@@ -168,8 +172,8 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
       l1BlockNumber: this.l1BlockNumber,
       l2SlotNumber,
       l2Epoch,
-      l2BlockNumber: this.l2BlockNumber,
-      l2ProvenBlockNumber: this.l2ProvenBlockNumber,
+      checkpointNumber: this.checkpointNumber,
+      provenCheckpointNumber: this.provenCheckpointNumber,
       totalL2Messages: this.totalL2Messages,
       committee,
     });
@@ -177,14 +181,13 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
     return this;
   }
 
-  public waitUntilL2Slot(slot: number | bigint): Promise<void> {
-    const targetSlot = typeof slot === 'bigint' ? slot.valueOf() : slot;
-    if (this.l2SlotNumber >= targetSlot) {
+  public waitUntilL2Slot(slot: SlotNumber): Promise<void> {
+    if (this.l2SlotNumber >= slot) {
       return Promise.resolve();
     }
     return new Promise(resolve => {
-      const listener = (data: { l2SlotNumber: number; timestamp: bigint }) => {
-        if (data.l2SlotNumber >= targetSlot) {
+      const listener = (data: { l2SlotNumber: SlotNumber; timestamp: bigint }) => {
+        if (data.l2SlotNumber >= slot) {
           this.off('l2-slot', listener);
           resolve();
         }
@@ -225,19 +228,18 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
     });
   }
 
-  public waitUntilL2Block(l2BlockNumber: number | bigint): Promise<void> {
-    const targetBlock = typeof l2BlockNumber === 'bigint' ? l2BlockNumber.valueOf() : l2BlockNumber;
-    if (this.l2BlockNumber >= targetBlock) {
+  public waitUntilCheckpoint(checkpointNumber: CheckpointNumber): Promise<void> {
+    if (this.checkpointNumber >= checkpointNumber) {
       return Promise.resolve();
     }
     return new Promise(resolve => {
-      const listener = (data: { l2BlockNumber: number; timestamp: bigint }) => {
-        if (data.l2BlockNumber >= targetBlock) {
-          this.off('l2-block', listener);
+      const listener = (data: { checkpointNumber: CheckpointNumber; timestamp: bigint }) => {
+        if (data.checkpointNumber >= checkpointNumber) {
+          this.off('checkpoint', listener);
           resolve();
         }
       };
-      this.on('l2-block', listener);
+      this.on('checkpoint', listener);
     });
   }
 }

package/src/test/eth_cheat_codes.ts

@@ -1,12 +1,13 @@
 import { toBigIntBE, toHex } from '@aztec/foundation/bigint-buffer';
-import { keccak256 } from '@aztec/foundation/crypto';
+import { keccak256 } from '@aztec/foundation/crypto/keccak';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 import { createLogger } from '@aztec/foundation/log';
 import { pluralize } from '@aztec/foundation/string';
 import type { DateProvider, TestDateProvider } from '@aztec/foundation/timer';
 
-import { type Hex, type Transaction, createPublicClient, fallback, hexToNumber, http } from 'viem';
+import { type Chain, type Hex, type Transaction, createPublicClient, fallback, hexToNumber, http } from 'viem';
+import { foundry } from 'viem/chains';
 
 import type { ViemPublicClient } from '../types.js';
 
@@ -28,9 +29,14 @@ export class EthCheatCodes {
      * The logger to use for the eth cheatcodes
      */
     public logger = createLogger('ethereum:cheat_codes'),
+    /**
+     * The chain configuration provided to Anvil
+     */
+    public chain: Chain = foundry,
   ) {
     this.publicClient = createPublicClient({
       transport: fallback(this.rpcUrls.map(url => http(url))),
+      chain: chain,
     });
   }