@aztec/ethereum 0.0.1-commit.03f7ef2 → 0.0.1-commit.08c5969dc

package/src/l1_tx_utils/fee-strategies/p75_competitive_blob_txs_only.ts

@@ -12,15 +12,6 @@ import {
   type PriorityFeeStrategyResult,
 } from './types.js';
 
-/**
- * Type for the promises required by the competitive strategy
- */
-type P75AllTxsStrategyPromises = {
-  networkEstimate: Promise<bigint>;
-  pendingBlock: Promise<Awaited<ReturnType<ViemClient['getBlock']>> | null>;
-  feeHistory: Promise<Awaited<ReturnType<ViemClient['getFeeHistory']>> | null>;
-};
-
 /**
  * Fetches historical blocks and calculates reward percentiles for blob transactions only.
  * Returns data in the same format as getFeeHistory for easy drop-in replacement.
@@ -114,38 +105,51 @@ export async function getBlobPriorityFeeHistory(
  * Analyzes p75 of pending transactions and 5-block fee history to determine a competitive priority fee.
  * Falls back to network estimate if data is unavailable.
  */
-export const P75BlobTxsOnlyPriorityFeeStrategy: PriorityFeeStrategy<P75AllTxsStrategyPromises> = {
+export const P75BlobTxsOnlyPriorityFeeStrategy: PriorityFeeStrategy = {
   name: 'Competitive (P75 + History) - Blob Txs Only',
   id: 'p75_pending_txs_and_history_blob_txs_only',
 
-  getRequiredPromises(client: ViemClient, opts: PriorityFeeStrategyContext): P75AllTxsStrategyPromises {
-    return {
-      networkEstimate: client.estimateMaxPriorityFeePerGas().catch(() => 0n),
-      pendingBlock: client.getBlock({ blockTag: 'pending', includeTransactions: true }).catch(() => null),
-      feeHistory: opts.isBlobTx
-        ? getBlobPriorityFeeHistory(client, HISTORICAL_BLOCK_COUNT, [75])
-        : client
-            .getFeeHistory({
-              blockCount: HISTORICAL_BLOCK_COUNT,
-              rewardPercentiles: [75],
-              blockTag: 'latest',
-            })
-            .catch(() => null),
-    };
-  },
-
-  calculate(
-    results: {
-      [K in keyof P75AllTxsStrategyPromises]: PromiseSettledResult<Awaited<P75AllTxsStrategyPromises[K]>>;
-    },
-    context: PriorityFeeStrategyContext,
-  ): PriorityFeeStrategyResult {
-    const { logger } = context;
+  async execute(client: ViemClient, context: PriorityFeeStrategyContext): Promise<PriorityFeeStrategyResult> {
+    const { isBlobTx, logger } = context;
+
+    // Fire all RPC calls in parallel
+    const [latestBlockResult, blobBaseFeeResult, networkEstimateResult, pendingBlockResult, feeHistoryResult] =
+      await Promise.allSettled([
+        client.getBlock({ blockTag: 'latest' }),
+        isBlobTx ? client.getBlobBaseFee() : Promise.resolve(undefined),
+        client.estimateMaxPriorityFeePerGas().catch(() => 0n),
+        client.getBlock({ blockTag: 'pending', includeTransactions: true }).catch(() => null),
+        isBlobTx
+          ? getBlobPriorityFeeHistory(client, HISTORICAL_BLOCK_COUNT, [75])
+          : client
+              .getFeeHistory({
+                blockCount: HISTORICAL_BLOCK_COUNT,
+                rewardPercentiles: [75],
+                blockTag: 'latest',
+              })
+              .catch(() => null),
+      ]);
+
+    // Extract latest block (required)
+    if (latestBlockResult.status === 'rejected') {
+      throw new Error(`Failed to get latest block: ${latestBlockResult.reason}`);
+    }
+    const latestBlock = latestBlockResult.value;
+
+    // Extract blob base fee (only for blob txs)
+    let blobBaseFee: bigint | undefined;
+    if (isBlobTx) {
+      if (blobBaseFeeResult.status === 'fulfilled' && typeof blobBaseFeeResult.value === 'bigint') {
+        blobBaseFee = blobBaseFeeResult.value;
+      } else {
+        logger?.warn('Failed to get L1 blob base fee');
+      }
+    }
 
-    // Extract network estimate from settled result
+    // Extract network estimate
     const networkEstimate =
-      results.networkEstimate.status === 'fulfilled' && typeof results.networkEstimate.value === 'bigint'
-        ? results.networkEstimate.value
+      networkEstimateResult.status === 'fulfilled' && typeof networkEstimateResult.value === 'bigint'
+        ? networkEstimateResult.value
         : 0n;
 
     let competitiveFee = networkEstimate;
@@ -153,8 +157,8 @@ export const P75BlobTxsOnlyPriorityFeeStrategy: PriorityFeeStrategy<P75AllTxsStr
       networkEstimateGwei: formatGwei(networkEstimate),
     };
 
-    // Extract pending block from settled result
-    const pendingBlock = results.pendingBlock.status === 'fulfilled' ? results.pendingBlock.value : null;
+    // Extract pending block
+    const pendingBlock = pendingBlockResult.status === 'fulfilled' ? pendingBlockResult.value : null;
 
     // Analyze pending block transactions
     if (pendingBlock?.transactions && pendingBlock.transactions.length > 0) {
@@ -163,14 +167,12 @@ export const P75BlobTxsOnlyPriorityFeeStrategy: PriorityFeeStrategy<P75AllTxsStr
           if (typeof tx === 'string') {
             return 0n;
           }
-          if (context.isBlobTx) {
+          if (isBlobTx) {
             if (!isBlobTransaction(tx)) {
               return 0n;
             }
           }
-          const fee = tx.maxPriorityFeePerGas || 0n;
-
-          return fee;
+          return tx.maxPriorityFeePerGas || 0n;
         })
         .filter((fee: bigint) => fee > 0n);
 
@@ -191,8 +193,8 @@ export const P75BlobTxsOnlyPriorityFeeStrategy: PriorityFeeStrategy<P75AllTxsStr
       }
     }
 
-    // Extract fee history from settled result
-    const feeHistory = results.feeHistory.status === 'fulfilled' ? results.feeHistory.value : null;
+    // Extract fee history
+    const feeHistory = feeHistoryResult.status === 'fulfilled' ? feeHistoryResult.value : null;
 
     // Analyze fee history
     if (feeHistory?.reward && feeHistory.reward.length > 0) {
@@ -205,7 +207,7 @@ export const P75BlobTxsOnlyPriorityFeeStrategy: PriorityFeeStrategy<P75AllTxsStr
 
         // Debug: Log suspicious fees from history
         if (medianHistoricalFee > 100n * WEI_CONST) {
-          logger?.warn('Suspicious high fee in history', {
+          logger?.debug('Suspicious high fee in history', {
             historicalMedian: formatGwei(medianHistoricalFee),
             allP75Fees: percentile75Fees.map(f => formatGwei(f)),
           });
@@ -235,6 +237,8 @@ export const P75BlobTxsOnlyPriorityFeeStrategy: PriorityFeeStrategy<P75AllTxsStr
 
     return {
       priorityFee: competitiveFee,
+      latestBlock,
+      blobBaseFee,
       debugInfo,
     };
   },

package/src/l1_tx_utils/fee-strategies/types.ts

@@ -1,5 +1,7 @@
 import type { Logger } from '@aztec/foundation/log';
 
+import type { Block } from 'viem';
+
 import type { ViemClient } from '../../types.js';
 import type { L1TxUtilsConfig } from '../config.js';
 
@@ -14,12 +16,16 @@ export const HISTORICAL_BLOCK_COUNT = 5;
 export interface PriorityFeeStrategyResult {
   /** The calculated priority fee in wei */
   priorityFee: bigint;
+  /** The latest block (fetched as part of the strategy) */
+  latestBlock: Block;
+  /** The blob base fee (only present for blob transactions) */
+  blobBaseFee?: bigint;
   /** Optional debug info about how the fee was calculated */
   debugInfo?: Record<string, string | number>;
 }
 
 /**
- * Context passed to the strategy calculation function (excluding promise results)
+ * Context passed to the strategy function
  */
 export interface PriorityFeeStrategyContext {
   /** Gas configuration */
@@ -32,57 +38,19 @@ export interface PriorityFeeStrategyContext {
 
 /**
  * A strategy for calculating the priority fee for L1 transactions.
- * Each strategy defines what promises it needs and how to calculate the fee from their results.
- * This design allows strategies to be plugged into both L1FeeAnalyzer and ReadOnlyL1TxUtils.
+ * The function handles all RPC calls and returns
+ * the priority fee, along with any block data needed by the caller.
  */
-export interface PriorityFeeStrategy<TPromises extends Record<string, Promise<any>> = Record<string, Promise<any>>> {
+export type PriorityFeeStrategy = {
   /** Human-readable name for logging */
   name: string;
   /** Unique identifier for metrics */
   id: string;
   /**
-   * Returns the promises that need to be executed for this strategy.
-   * These will be run in parallel with Promise.allSettled.
+   * Calculate the priority fee.
    * @param client - The viem client to use for RPC calls
-   * @returns An object of promises keyed by name
-   */
-  getRequiredPromises(client: ViemClient, opts: Partial<PriorityFeeStrategyContext>): TPromises;
-  /**
-   * Calculate the priority fee based on the settled promise results.
-   * @param results - The settled results of the promises from getRequiredPromises
    * @param context - Contains gas config, whether it's a blob tx, and logger
-   * @returns The calculated priority fee result
+   * @returns The calculated priority fee result including block data
    */
-  calculate(
-    results: { [K in keyof TPromises]: PromiseSettledResult<Awaited<TPromises[K]>> },
-    context: PriorityFeeStrategyContext,
-  ): PriorityFeeStrategyResult;
-}
-
-/**
- * Helper function to execute a strategy's promises and calculate the result.
- * This can be used by both L1FeeAnalyzer and ReadOnlyL1TxUtils.
- * @param strategy - The strategy to execute
- * @param client - The viem client to use for RPC calls
- * @param context - The context for calculation
- * @returns The strategy result
- */
-export async function executeStrategy<TPromises extends Record<string, Promise<any>>>(
-  strategy: PriorityFeeStrategy<TPromises>,
-  client: ViemClient,
-  context: PriorityFeeStrategyContext,
-): Promise<PriorityFeeStrategyResult> {
-  const promises = strategy.getRequiredPromises(client, { isBlobTx: context.isBlobTx });
-  const keys = Object.keys(promises) as Array<keyof TPromises>;
-  const promiseArray = keys.map(k => promises[k]);
-
-  const settledResults = await Promise.allSettled(promiseArray);
-
-  // Reconstruct the results object with the same keys, preserving the type mapping
-  const results = {} as { [K in keyof TPromises]: PromiseSettledResult<Awaited<TPromises[K]>> };
-  keys.forEach((key, index) => {
-    results[key] = settledResults[index] as PromiseSettledResult<Awaited<TPromises[typeof key]>>;
-  });
-
-  return strategy.calculate(results, context);
-}
+  execute: (client: ViemClient, context: PriorityFeeStrategyContext) => Promise<PriorityFeeStrategyResult>;
+};

package/src/l1_tx_utils/l1_fee_analyzer.ts

@@ -13,7 +13,6 @@ import {
   DEFAULT_PRIORITY_FEE_STRATEGIES,
   type PriorityFeeStrategy,
   type PriorityFeeStrategyContext,
-  executeStrategy,
 } from './fee-strategies/index.js';
 import type { L1BlobInputs, L1TxRequest } from './types.js';
 
@@ -262,7 +261,7 @@ export class L1FeeAnalyzer {
 
   /**
    * Executes all configured strategies and returns their results.
-   * Each strategy defines its own promises which are executed and passed to calculate.
+   * Each strategy handles its own RPC calls internally.
    * @param isBlobTx - Whether this is a blob transaction
    * @returns Array of strategy results
    */
@@ -276,7 +275,7 @@ export class L1FeeAnalyzer {
 
     for (const strategy of this.strategies) {
       try {
-        const result = await executeStrategy(strategy, this.client, context);
+        const result = await strategy.execute(this.client, context);
 
         results.push({
           strategyId: strategy.id,

package/src/l1_tx_utils/l1_tx_utils.ts

@@ -27,7 +27,7 @@ import { jsonRpc } from 'viem/nonce';
 import type { ViemClient } from '../types.js';
 import { formatViemError } from '../utils.js';
 import { type L1TxUtilsConfig, l1TxUtilsConfigMappings } from './config.js';
-import { LARGE_GAS_LIMIT } from './constants.js';
+import { MAX_L1_TX_LIMIT } from './constants.js';
 import type { IL1TxMetrics, IL1TxStore } from './interfaces.js';
 import { ReadOnlyL1TxUtils } from './readonly_l1_tx_utils.js';
 import {
@@ -207,7 +207,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
 
       let gasLimit: bigint;
       if (this.debugMaxGasLimit) {
-        gasLimit = LARGE_GAS_LIMIT;
+        gasLimit = MAX_L1_TX_LIMIT;
       } else if (gasConfig.gasLimit) {
         gasLimit = gasConfig.gasLimit;
       } else {
@@ -283,7 +283,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
       return { txHash, state: l1TxState };
     } catch (err: any) {
       const viemError = formatViemError(err, request.abi);
-      this.logger.error(`Failed to send L1 transaction`, viemError, {
+      this.logger.error(`Failed to send L1 transaction: ${viemError.message}`, viemError, {
         request: pick(request, 'to', 'value'),
       });
       throw viemError;
@@ -631,12 +631,12 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
       from: request.from ?? this.getSenderAddress().toString(),
       maxFeePerGas: gasPrice.maxFeePerGas,
       maxPriorityFeePerGas: gasPrice.maxPriorityFeePerGas,
-      gas: request.gas ?? LARGE_GAS_LIMIT,
+      gas: request.gas ?? MAX_L1_TX_LIMIT,
     };
 
     if (!request.gas && !gasConfig.ignoreBlockGasLimit) {
-      // LARGE_GAS_LIMIT is set as call.gas, increase block gasLimit
-      blockOverrides.gasLimit = LARGE_GAS_LIMIT * 2n;
+      // MAX_L1_TX_LIMIT is set as call.gas, ensure block gasLimit is sufficient
+      blockOverrides.gasLimit = MAX_L1_TX_LIMIT;
     }
 
     return this._simulate(call, blockOverrides, stateOverrides, gasConfig, abi);

package/src/l1_tx_utils/readonly_l1_tx_utils.ts

@@ -27,7 +27,7 @@ import type { ViemClient } from '../types.js';
 import { type L1TxUtilsConfig, defaultL1TxUtilsConfig, l1TxUtilsConfigMappings } from './config.js';
 import {
   BLOCK_TIME_MS,
-  LARGE_GAS_LIMIT,
+  MAX_L1_TX_LIMIT,
   MIN_BLOB_REPLACEMENT_BUMP_PERCENTAGE,
   MIN_REPLACEMENT_BUMP_PERCENTAGE,
   WEI_CONST,
@@ -84,63 +84,31 @@ export class ReadOnlyL1TxUtils {
   ): Promise<GasPrice> {
     const gasConfig = merge(this.config, gasConfigOverrides);
 
-    // Make all RPC calls in parallel upfront with retry logic
-    // First 2 calls are necessary to complete
-    const latestBlockPromise = this.tryTwice(
-      () => this.client.getBlock({ blockTag: 'latest' }),
-      'Getting latest block',
+    // Execute strategy - it handles all RPC calls internally and returns everything we need
+    const strategyResult = await retry(
+      () =>
+        CurrentStrategy.execute(this.client, {
+          gasConfig,
+          isBlobTx,
+          logger: this.logger,
+        }),
+      'Executing priority fee strategy',
+      makeBackoff(times(2, () => 0)),
+      this.logger,
+      true,
     );
 
-    let blobBaseFeePromise = null;
-    if (isBlobTx) {
-      blobBaseFeePromise = this.tryTwice(() => this.client.getBlobBaseFee(), 'Getting blob base fee');
-    }
+    const { latestBlock, blobBaseFee, priorityFee: strategyPriorityFee } = strategyResult;
 
-    // Get strategy promises for priority fee calculation
-    const strategyPromises = CurrentStrategy.getRequiredPromises(this.client, { isBlobTx });
-    const strategyPromiseKeys = [];
-    const strategyPromisesArr = [];
-    for (const [key, promise] of Object.entries(strategyPromises)) {
-      strategyPromiseKeys.push(key);
-      strategyPromisesArr.push(this.tryTwice(() => promise, `Getting strategy data for ${key}`));
-    }
+    // Extract base fee from latest block
+    const baseFee = latestBlock.baseFeePerGas ?? 0n;
 
-    const [latestBlockResult, blobBaseFeeResult, ...strategyResults] = await Promise.allSettled([
-      latestBlockPromise,
-      blobBaseFeePromise ?? Promise.resolve(0n),
-      ...strategyPromisesArr,
-    ]);
-
-    // 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 && blobBaseFeeResult.status === 'fulfilled' && typeof blobBaseFeeResult.value === 'bigint') {
-      blobBaseFee = blobBaseFeeResult.value;
-    } else if (isBlobTx) {
+    // Handle blob base fee
+    if (isBlobTx && blobBaseFee === undefined) {
       this.logger?.warn('Failed to get L1 blob base fee', attempt);
     }
 
-    let priorityFee: bigint;
-    // Get competitive priority fee using strategy
-    // Reconstruct the results object with the same keys as the promises
-    const resultsObject: Record<string, PromiseSettledResult<unknown>> = {};
-    strategyPromiseKeys.forEach((key, index) => {
-      resultsObject[key] = strategyResults[index];
-    });
-
-    const result = CurrentStrategy.calculate(resultsObject as any, {
-      gasConfig,
-      isBlobTx,
-      logger: this.logger,
-    });
-    priorityFee = result.priorityFee;
+    let priorityFee = strategyPriorityFee;
 
     // Apply minimum priority fee floor if configured
     if (gasConfig.minimumPriorityFeePerGas) {
@@ -156,7 +124,7 @@ export class ReadOnlyL1TxUtils {
     }
     let maxFeePerGas = baseFee;
 
-    let maxFeePerBlobGas = blobBaseFee;
+    let maxFeePerBlobGas = blobBaseFee ?? 0n;
 
     // Bump base fee so it's valid for next blocks if it stalls
     const numBlocks = Math.ceil(gasConfig.stallTimeMs! / BLOCK_TIME_MS);
@@ -250,7 +218,7 @@ export class ReadOnlyL1TxUtils {
         baseFee: formatGwei(baseFee),
         maxFeePerGas: formatGwei(maxFeePerGas),
         maxPriorityFeePerGas: formatGwei(maxPriorityFeePerGas),
-        blobBaseFee: formatGwei(blobBaseFee),
+        blobBaseFee: formatGwei(blobBaseFee ?? 0n),
         maxFeePerBlobGas: formatGwei(maxFeePerBlobGas),
       },
     );
@@ -281,7 +249,7 @@ export class ReadOnlyL1TxUtils {
         ...request,
         ..._blobInputs,
         maxFeePerBlobGas: gasPrice.maxFeePerBlobGas!,
-        gas: LARGE_GAS_LIMIT,
+        gas: MAX_L1_TX_LIMIT,
         blockTag: 'latest',
       });
 
@@ -290,7 +258,7 @@ export class ReadOnlyL1TxUtils {
       initialEstimate = await this.client.estimateGas({
         account,
         ...request,
-        gas: LARGE_GAS_LIMIT,
+        gas: MAX_L1_TX_LIMIT,
         blockTag: 'latest',
       });
       this.logger?.trace(`Estimated gas for non-blob tx: ${initialEstimate}`);
@@ -448,11 +416,4 @@ 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/publisher_manager.ts

@@ -1,5 +1,5 @@
 import { pick } from '@aztec/foundation/collection';
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 
 import { L1TxUtils, TxUtilsState } from './l1_tx_utils/index.js';
 
@@ -28,13 +28,15 @@ const busyStates: TxUtilsState[] = [
 export type PublisherFilter<UtilsType extends L1TxUtils> = (utils: UtilsType) => boolean;
 
 export class PublisherManager<UtilsType extends L1TxUtils = L1TxUtils> {
-  private log = createLogger('publisher:manager');
+  private log: Logger;
   private config: { publisherAllowInvalidStates?: boolean };
 
   constructor(
     private publishers: UtilsType[],
     config: { publisherAllowInvalidStates?: boolean },
+    bindings?: LoggerBindings,
   ) {
+    this.log = createLogger('publisher:manager', bindings);
     this.log.info(`PublisherManager initialized with ${publishers.length} publishers.`);
     this.publishers = publishers;
     this.config = pick(config, 'publisherAllowInvalidStates');

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

@@ -156,7 +156,7 @@ 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} `;
     }

package/src/test/rollup_cheat_codes.ts

@@ -1,4 +1,4 @@
-import { RollupContract } from '@aztec/ethereum/contracts';
+import { OutboxContract, RollupContract } from '@aztec/ethereum/contracts';
 import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
 import type { ViemPublicClient } from '@aztec/ethereum/types';
 import { CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
@@ -56,6 +56,15 @@ export class RollupCheatCodes {
     return SlotNumber.fromBigInt(await this.rollup.read.getSlotAt([ts]));
   }
 
+  /** Returns the number of seconds until the start of the given slot based on L1 block timestamp. */
+  public async getSecondsUntilSlot(slot: SlotNumber): Promise<number> {
+    const [currentTimestamp, targetTimestamp] = await Promise.all([
+      this.client.getBlock().then(b => BigInt(b.timestamp)),
+      this.rollup.read.getTimestampForSlot([BigInt(slot)]),
+    ]);
+    return Math.max(0, Number(targetTimestamp - currentTimestamp));
+  }
+
   /** Returns the current epoch */
   public async getEpoch(): Promise<EpochNumber> {
     const slotNumber = await this.getSlot();
@@ -124,7 +133,7 @@ export class RollupCheatCodes {
     } = {},
   ) {
     const { epochDuration: slotsInEpoch } = await this.getConfig();
-    const slotNumber = SlotNumber(epoch * Number(slotsInEpoch));
+    const slotNumber = SlotNumber(Number(epoch) * Number(slotsInEpoch));
     const timestamp = (await this.rollup.read.getTimestampForSlot([BigInt(slotNumber)])) + BigInt(opts.offset ?? 0);
     try {
       await this.ethCheatCodes.warp(Number(timestamp), { ...opts, silent: true, resetBlockInterval: true });
@@ -176,7 +185,7 @@ export class RollupCheatCodes {
    * Marks the specified checkpoint (or latest if none) as proven
    * @param maybeCheckpointNumber - The checkpoint number to mark as proven (defaults to latest pending)
    */
-  public markAsProven(maybeCheckpointNumber?: number | bigint) {
+  public markAsProven(maybeCheckpointNumber?: CheckpointNumber) {
     return this.ethCheatCodes.execWithPausedAnvil(async () => {
       const tipsBefore = await this.getTips();
       const { pending, proven } = tipsBefore;
@@ -250,6 +259,15 @@ export class RollupCheatCodes {
     });
   }
 
+  public insertOutbox(epoch: EpochNumber, outHash: bigint) {
+    return this.ethCheatCodes.execWithPausedAnvil(async () => {
+      const outboxAddress = await this.rollup.read.getOutbox();
+      const epochRootSlot = OutboxContract.getEpochRootStorageSlot(epoch);
+      await this.ethCheatCodes.store(EthAddress.fromString(outboxAddress), epochRootSlot, outHash);
+      this.logger.warn(`Advanced outbox to epoch ${epoch} with out hash ${outHash}`);
+    });
+  }
+
   /**
    * Executes an action impersonated as the owner of the Rollup contract.
    * @param action - The action to execute

package/src/test/start_anvil.ts

@@ -33,7 +33,7 @@ export async function startAnvil(
       const anvil = createAnvil({
         anvilBinary,
         host: '127.0.0.1',
-        port: opts.port ?? 8545,
+        port: opts.port ?? (process.env.ANVIL_PORT ? parseInt(process.env.ANVIL_PORT) : 8545),
         blockTime: opts.l1BlockTime,
         stopTimeout: 1000,
         accounts: opts.accounts ?? 20,