@aztec/ethereum 3.0.3 → 4.0.0-devnet.1-patch.0

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

@@ -1,4 +1,5 @@
-import { getKeys, median, merge, pick, times } from '@aztec/foundation/collection';
+import { getKeys, merge, pick, times } from '@aztec/foundation/collection';
+import type { EthAddress } from '@aztec/foundation/eth-address';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { makeBackoff, retry } from '@aztec/foundation/retry';
 import { DateProvider } from '@aztec/foundation/timer';
@@ -11,6 +12,7 @@ import {
   type BaseError,
   type BlockOverrides,
   type ContractFunctionExecutionError,
+  type GetCodeReturnType,
   type Hex,
   MethodNotFoundRpcError,
   MethodNotSupportedRpcError,
@@ -25,15 +27,17 @@ 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,
 } from './constants.js';
+import { P75AllTxsPriorityFeeStrategy, type PriorityFeeStrategy } from './fee-strategies/index.js';
 import type { GasPrice, L1BlobInputs, L1TxRequest, TransactionStats } from './types.js';
 import { getCalldataGasUsage, tryGetCustomErrorNameContractFunction } from './utils.js';
 
-const HISTORICAL_BLOCK_COUNT = 5;
+// Change this to the current strategy we want to use
+const CurrentStrategy: PriorityFeeStrategy = P75AllTxsPriorityFeeStrategy;
 
 export class ReadOnlyL1TxUtils {
   public config: Required<L1TxUtilsConfig>;
@@ -65,122 +69,8 @@ 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;
+  public getCode(address: EthAddress): Promise<GetCodeReturnType> {
+    return this.client.getCode({ address: address.toString() });
   }
 
   /**
@@ -194,74 +84,47 @@ export class ReadOnlyL1TxUtils {
   ): Promise<GasPrice> {
     const gasConfig = merge(this.config, gasConfigOverrides);
 
-    // 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',
+    // 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,
     );
-    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 && blobBaseFeeResult.status === 'fulfilled' && typeof blobBaseFeeResult.value === 'bigint') {
-      blobBaseFee = blobBaseFeeResult.value;
-    } else if (isBlobTx) {
+
+    const { latestBlock, blobBaseFee, priorityFee: strategyPriorityFee } = strategyResult;
+
+    // Extract base fee from latest block
+    const baseFee = latestBlock.baseFeePerGas ?? 0n;
+
+    // Handle blob base fee
+    if (isBlobTx && blobBaseFee === undefined) {
       this.logger?.warn('Failed to get L1 blob base fee', attempt);
     }
 
-    // Get competitive priority fee
-    let priorityFee = this.getCompetitivePriorityFee(networkEstimateResult, pendingBlockResult, feeHistoryResult);
+    let priorityFee = strategyPriorityFee;
 
-    // Apply minimum priority fee as a floor if configured
+    // Apply minimum priority fee 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),
+      const minimumPriorityFee = BigInt(Math.trunc(gasConfig.minimumPriorityFeePerGas * Number(WEI_CONST)));
+      if (priorityFee < minimumPriorityFee) {
+        this.logger?.debug('Applying minimum priority fee floor', {
+          calculatedPriorityFee: formatGwei(priorityFee),
+          minimumPriorityFeePerGas: gasConfig.minimumPriorityFeePerGas,
+          appliedFee: formatGwei(minimumPriorityFee),
         });
+        priorityFee = minimumPriorityFee;
       }
     }
     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);
@@ -355,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),
       },
     );
@@ -386,12 +249,18 @@ export class ReadOnlyL1TxUtils {
         ...request,
         ..._blobInputs,
         maxFeePerBlobGas: gasPrice.maxFeePerBlobGas!,
-        gas: LARGE_GAS_LIMIT,
+        gas: MAX_L1_TX_LIMIT,
+        blockTag: 'latest',
       });
 
       this.logger?.trace(`Estimated gas for blob tx: ${initialEstimate}`);
     } else {
-      initialEstimate = await this.client.estimateGas({ account, ...request, gas: LARGE_GAS_LIMIT });
+      initialEstimate = await this.client.estimateGas({
+        account,
+        ...request,
+        gas: MAX_L1_TX_LIMIT,
+        blockTag: 'latest',
+      });
       this.logger?.trace(`Estimated gas for non-blob tx: ${initialEstimate}`);
     }
 
@@ -547,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/eth_cheat_codes.ts

@@ -35,7 +35,7 @@ export class EthCheatCodes {
     public chain: Chain = foundry,
   ) {
     this.publicClient = createPublicClient({
-      transport: fallback(this.rpcUrls.map(url => http(url))),
+      transport: fallback(this.rpcUrls.map(url => http(url, { batch: false }))),
       chain: chain,
     });
   }

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';
@@ -32,7 +32,7 @@ export class RollupCheatCodes {
   ) {
     this.client = createPublicClient({
       chain: ethCheatCodes.chain,
-      transport: fallback(ethCheatCodes.rpcUrls.map(url => http(url))),
+      transport: fallback(ethCheatCodes.rpcUrls.map(url => http(url, { batch: false }))),
     });
     this.rollup = getContract({
       abi: RollupAbi,
@@ -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,

package/src/test/tx_delayer.ts

@@ -232,7 +232,7 @@ export function withDelayer<T extends ViemClient>(
           return Promise.resolve(txHash!);
         } else {
           const txHash = await client.sendRawTransaction(...args);
-          logger.verbose(`Sent tx immediately ${txHash}`);
+          logger.debug(`Sent tx immediately ${txHash}`);
           delayer.sentTxHashes.push(txHash);
           return txHash;
         }

package/src/utils.ts

@@ -4,15 +4,18 @@ import { ErrorsAbi } from '@aztec/l1-artifacts/ErrorsAbi';
 
 import {
   type Abi,
+  type AbiItem,
   BaseError,
   type ContractEventName,
   ContractFunctionRevertedError,
   type DecodeEventLogReturnType,
+  type FormattedTransaction,
   type Hex,
   type Log,
   decodeErrorResult,
   decodeEventLog,
 } from 'viem';
+import { formatAbiItem, formatAbiParams } from 'viem/utils';
 
 export interface L2Claim {
   claimSecret: Fr;
@@ -92,6 +95,57 @@ export function prettyLogViemErrorMsg(err: any) {
   return err?.message ?? err;
 }
 
+export function mergeAbis(abis: Abi[]): Abi {
+  let merged: Abi = [];
+  const seen = new Set<string>();
+
+  for (const abi of abis) {
+    for (const item of abi) {
+      const key = getAbiItemKey(item);
+      if (!seen.has(key)) {
+        seen.add(key);
+        merged = [...merged, item];
+      }
+    }
+  }
+
+  return merged;
+}
+
+function getAbiItemKey(item: AbiItem): string {
+  if (item.type === 'function') {
+    const signature = formatAbiItem(item);
+    const outputs = formatAbiParams(item.outputs);
+    const stateMutability = typeof item.stateMutability === 'string' ? item.stateMutability : '';
+    return `function:${signature}:${outputs}:${stateMutability}`;
+  }
+
+  if (item.type === 'event') {
+    const signature = formatAbiItem(item);
+    const indexed = (item.inputs ?? []).map(input => ((input as { indexed?: boolean }).indexed ? '1' : '0')).join('');
+    const anonymous = item.anonymous ? 'anonymous' : 'not-anonymous';
+    return `event:${signature}:${indexed}:${anonymous}`;
+  }
+
+  if (item.type === 'error') {
+    const signature = formatAbiItem(item);
+    return `error:${signature}`;
+  }
+
+  if (item.type === 'constructor') {
+    const inputs = formatAbiParams(item.inputs);
+    const stateMutability = typeof item.stateMutability === 'string' ? item.stateMutability : '';
+    return `constructor::${inputs}:${stateMutability}`;
+  }
+
+  if (item.type === 'fallback' || item.type === 'receive') {
+    const stateMutability = typeof item.stateMutability === 'string' ? item.stateMutability : '';
+    return `${item.type}:::${stateMutability}`;
+  }
+
+  return 'unknown';
+}
+
 function getNestedErrorData(error: unknown): string | undefined {
   // If nothing, bail
   if (!error) {
@@ -233,3 +287,31 @@ export function tryGetCustomErrorName(err: any) {
     return undefined;
   }
 }
+
+/**
+ * Type guard to check if a transaction is a blob transaction (EIP-4844).
+ * Blob transactions have maxFeePerBlobGas and blobVersionedHashes fields.
+ */
+export function isBlobTransaction(tx: FormattedTransaction): tx is FormattedTransaction & {
+  maxFeePerBlobGas: bigint;
+  blobVersionedHashes: readonly Hex[];
+} {
+  return (
+    'maxFeePerBlobGas' in tx &&
+    tx.maxFeePerBlobGas !== undefined &&
+    'blobVersionedHashes' in tx &&
+    tx.blobVersionedHashes !== undefined
+  );
+}
+
+/**
+ * Calculates a percentile from an array of bigints
+ */
+export function calculatePercentile(values: bigint[], percentile: number): bigint {
+  if (values.length === 0) {
+    return 0n;
+  }
+  const sorted = [...values].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+  const index = Math.ceil((sorted.length - 1) * (percentile / 100));
+  return sorted[index];
+}