@aztec/ethereum 0.0.1-commit.6d3c34e → 0.0.1-commit.7cf39cb55

package/src/contracts/tally_slashing_proposer.ts

@@ -1,11 +1,12 @@
 import type { L1TxRequest } from '@aztec/ethereum/l1-tx-utils';
 import type { ViemClient } from '@aztec/ethereum/types';
-import { tryExtractEvent } from '@aztec/ethereum/utils';
+import { mergeAbis, tryExtractEvent } from '@aztec/ethereum/utils';
 import { SlotNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
 import { hexToBuffer } from '@aztec/foundation/string';
+import { SlasherAbi } from '@aztec/l1-artifacts/SlasherAbi';
 import { TallySlashingProposerAbi } from '@aztec/l1-artifacts/TallySlashingProposerAbi';
 
 import {
@@ -160,6 +161,7 @@ export class TallySlashingProposerContract {
 
     return {
       to: this.contract.address,
+      abi: TallySlashingProposerAbi,
       data: encodeFunctionData({
         abi: TallySlashingProposerAbi,
         functionName: 'vote',
@@ -207,6 +209,7 @@ export class TallySlashingProposerContract {
   public buildVoteRequestWithSignature(votes: Hex, signature: { v: number; r: Hex; s: Hex }): L1TxRequest {
     return {
       to: this.contract.address,
+      abi: TallySlashingProposerAbi,
       data: encodeFunctionData({
         abi: TallySlashingProposerAbi,
         functionName: 'vote',
@@ -224,6 +227,7 @@ export class TallySlashingProposerContract {
   public buildExecuteRoundRequest(round: bigint, committees: EthAddress[][]): L1TxRequest {
     return {
       to: this.contract.address,
+      abi: mergeAbis([TallySlashingProposerAbi, SlasherAbi]),
       data: encodeFunctionData({
         abi: TallySlashingProposerAbi,
         functionName: 'executeRound',

package/src/deploy_aztec_l1_contracts.ts

@@ -10,12 +10,12 @@ import { fileURLToPath } from '@aztec/foundation/url';
 import { bn254 } from '@noble/curves/bn254';
 import type { Abi, Narrow } from 'abitype';
 import { spawn } from 'child_process';
-import { cpSync, existsSync, mkdirSync, mkdtempSync, readdirSync, rmSync } from 'fs';
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs';
 import { tmpdir } from 'os';
 import { dirname, join, resolve } from 'path';
 import readline from 'readline';
 import type { Hex } from 'viem';
-import { foundry, mainnet, sepolia } from 'viem/chains';
+import { mainnet, sepolia } from 'viem/chains';
 
 import { createEthereumChain, isAnvilTestChain } from './chain.js';
 import { createExtendedL1Client } from './client.js';
@@ -31,9 +31,9 @@ const logger = createLogger('ethereum:deploy_aztec_l1_contracts');
 const JSON_DEPLOY_RESULT_PREFIX = 'JSON DEPLOY RESULT:';
 
 /**
- * Runs a process with the given command, arguments, and environment.
- * If the process outputs a line starting with JSON_DEPLOY_RESULT_PREFIX,
- * the JSON is parsed and returned.
+ * Runs a process and parses JSON deploy results from stdout.
+ * Lines starting with JSON_DEPLOY_RESULT_PREFIX are parsed and returned.
+ * All other stdout goes to logger.info, stderr goes to logger.warn.
  */
 function runProcess<T>(
   command: string,
@@ -49,26 +49,41 @@ function runProcess<T>(
   });
 
   let result: T | undefined;
+  let parseError: Error | undefined;
+  let settled = false;
 
   readline.createInterface({ input: proc.stdout }).on('line', line => {
     const trimmedLine = line.trim();
     if (trimmedLine.startsWith(JSON_DEPLOY_RESULT_PREFIX)) {
       const jsonStr = trimmedLine.slice(JSON_DEPLOY_RESULT_PREFIX.length).trim();
-      // TODO(AD): should this be a zod parse?
-      result = JSON.parse(jsonStr);
+      try {
+        result = JSON.parse(jsonStr);
+      } catch {
+        parseError = new Error(`Failed to parse deploy result JSON: ${jsonStr.slice(0, 200)}`);
+      }
     } else {
       logger.info(line);
     }
   });
-  readline.createInterface({ input: proc.stderr }).on('line', logger.error.bind(logger));
+  readline.createInterface({ input: proc.stderr }).on('line', logger.warn.bind(logger));
 
   proc.on('error', error => {
+    if (settled) {
+      return;
+    }
+    settled = true;
     reject(new Error(`Failed to spawn ${command}: ${error.message}`));
   });
 
   proc.on('close', code => {
+    if (settled) {
+      return;
+    }
+    settled = true;
     if (code !== 0) {
-      reject(new Error(`${command} exited with code ${code}. See logs for details.\n`));
+      reject(new Error(`${command} exited with code ${code}`));
+    } else if (parseError) {
+      reject(parseError);
     } else {
       resolve(result);
     }
@@ -141,11 +156,14 @@ function cleanupDeployDir() {
  */
 export function prepareL1ContractsForDeployment(): string {
   if (preparedDeployDir && existsSync(preparedDeployDir)) {
+    logger.verbose(`Using cached deployment directory: ${preparedDeployDir}`);
     return preparedDeployDir;
   }
 
   const basePath = getL1ContractsPath();
+  logger.verbose(`Preparing L1 contracts from: ${basePath}`);
   const tempDir = mkdtempSync(join(tmpdir(), '.foundry-deploy-'));
+  logger.verbose(`Created temp directory for deployment: ${tempDir}`);
   preparedDeployDir = tempDir;
   process.on('exit', cleanupDeployDir);
 
@@ -157,13 +175,24 @@ export function prepareL1ContractsForDeployment(): string {
   cpSync(join(basePath, 'src'), join(tempDir, 'src'), copyOpts);
   cpSync(join(basePath, 'script'), join(tempDir, 'script'), copyOpts);
   cpSync(join(basePath, 'generated'), join(tempDir, 'generated'), copyOpts);
-  cpSync(join(basePath, 'foundry.toml'), join(tempDir, 'foundry.toml'));
+  // Kludge: copy test/ to appease forge cache which references test/shouting.t.sol
+  cpSync(join(basePath, 'test'), join(tempDir, 'test'), copyOpts);
   cpSync(join(basePath, 'foundry.lock'), join(tempDir, 'foundry.lock'));
-  for (const file of readdirSync(basePath)) {
-    if (file.startsWith('solc-')) {
-      cpSync(join(basePath, file), join(tempDir, file));
-    }
+
+  // Update foundry.toml to use absolute path to solc binary (avoids copying to noexec tmpfs)
+  const foundryTomlPath = join(basePath, 'foundry.toml');
+  let foundryToml = readFileSync(foundryTomlPath, 'utf-8');
+  const solcPathMatch = foundryToml.match(/solc\s*=\s*"\.\/solc-([^"]+)"/);
+  // Did we find a hardcoded solc path that we need to make absolute?
+  // This code path happens in CI currently as we bundle solc there to avoid race conditions when
+  // downloading solc.
+  if (solcPathMatch) {
+    const solcVersion = solcPathMatch[1];
+    const absoluteSolcPath = join(basePath, `solc-${solcVersion}`);
+    foundryToml = foundryToml.replace(/solc\s*=\s*"\.\/solc-[^"]+"/, `solc = "${absoluteSolcPath}"`);
+    logger.verbose(`Updated solc path in foundry.toml to: ${absoluteSolcPath}`);
   }
+  writeFileSync(join(tempDir, 'foundry.toml'), foundryToml);
 
   mkdirSync(join(tempDir, 'broadcast'));
   return tempDir;
@@ -307,11 +336,8 @@ export async function deployAztecL1Contracts(
     );
   }
 
-  // From heuristic testing. More caused issues with anvil.
-  const MAGIC_ANVIL_BATCH_SIZE = 12;
-  // Anvil seems to stall with unbounded batch size. Otherwise no max batch size is desirable.
+  const scriptPath = join(getL1ContractsPath(), 'scripts', 'forge_broadcast.js');
   const forgeArgs = [
-    'script',
     FORGE_SCRIPT,
     '--sig',
     'run()',
@@ -319,8 +345,6 @@ export async function deployAztecL1Contracts(
     privateKey,
     '--rpc-url',
     rpcUrl,
-    '--broadcast',
-    ...(chainId === foundry.id ? ['--batch-size', MAGIC_ANVIL_BATCH_SIZE.toString()] : []),
     ...(shouldVerify ? ['--verify'] : []),
   ];
   const forgeEnv = {
@@ -329,7 +353,12 @@ export async function deployAztecL1Contracts(
     FOUNDRY_PROFILE: chainId === mainnet.id ? 'production' : undefined,
     ...getDeployAztecL1ContractsEnvVars(args),
   };
-  const result = await runProcess<ForgeL1ContractsDeployResult>('forge', forgeArgs, forgeEnv, l1ContractsPath);
+  const result = await runProcess<ForgeL1ContractsDeployResult>(
+    process.execPath,
+    [scriptPath, ...forgeArgs],
+    forgeEnv,
+    l1ContractsPath,
+  );
   if (!result) {
     throw new Error('Forge script did not output deployment result');
   }
@@ -497,6 +526,7 @@ export function getDeployAztecL1ContractsEnvVars(args: DeployAztecL1ContractsArg
     AZTEC_EJECTION_THRESHOLD: args.ejectionThreshold?.toString(),
     AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: args.governanceProposerRoundSize?.toString(),
     AZTEC_GOVERNANCE_PROPOSER_QUORUM: args.governanceProposerQuorum?.toString(),
+    AZTEC_GOVERNANCE_VOTING_DURATION: args.governanceVotingDuration?.toString(),
     ZKPASSPORT_DOMAIN: args.zkPassportArgs?.zkPassportDomain,
     ZKPASSPORT_SCOPE: args.zkPassportArgs?.zkPassportScope,
   } as const;
@@ -531,11 +561,13 @@ export function getDeployRollupForUpgradeEnvVars(
     AZTEC_PROOF_SUBMISSION_EPOCHS: args.aztecProofSubmissionEpochs.toString(),
     AZTEC_LOCAL_EJECTION_THRESHOLD: args.localEjectionThreshold.toString(),
     AZTEC_SLASHING_LIFETIME_IN_ROUNDS: args.slashingLifetimeInRounds.toString(),
+    AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS: args.slashingExecutionDelayInRounds.toString(),
     AZTEC_SLASHING_VETOER: args.slashingVetoer.toString(),
     AZTEC_SLASHING_DISABLE_DURATION: args.slashingDisableDuration.toString(),
     AZTEC_MANA_TARGET: args.manaTarget.toString(),
     AZTEC_EXIT_DELAY_SECONDS: args.exitDelaySeconds.toString(),
     AZTEC_PROVING_COST_PER_MANA: args.provingCostPerMana.toString(),
+    AZTEC_INITIAL_ETH_PER_FEE_ASSET: args.initialEthPerFeeAsset.toString(),
     AZTEC_SLASHER_FLAVOR: args.slasherFlavor,
     AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: args.slashingRoundSizeInEpochs.toString(),
     AZTEC_SLASHING_QUORUM: args.slashingQuorum?.toString(),
@@ -569,17 +601,8 @@ export const deployRollupForUpgrade = async (
   const FORGE_SCRIPT = 'script/deploy/DeployRollupForUpgrade.s.sol';
   await maybeForgeForceProductionBuild(l1ContractsPath, FORGE_SCRIPT, chainId);
 
-  const forgeArgs = [
-    'script',
-    FORGE_SCRIPT,
-    '--sig',
-    'run()',
-    '--private-key',
-    privateKey,
-    '--rpc-url',
-    rpcUrl,
-    '--broadcast',
-  ];
+  const scriptPath = join(getL1ContractsPath(), 'scripts', 'forge_broadcast.js');
+  const forgeArgs = [FORGE_SCRIPT, '--sig', 'run()', '--private-key', privateKey, '--rpc-url', rpcUrl];
   const forgeEnv = {
     FOUNDRY_PROFILE: chainId === mainnet.id ? 'production' : undefined,
     // Env vars required by l1-contracts/script/deploy/RollupConfiguration.sol.
@@ -588,7 +611,12 @@ export const deployRollupForUpgrade = async (
     ...getDeployRollupForUpgradeEnvVars(args),
   };
 
-  const result = await runProcess<ForgeRollupUpgradeResult>('forge', forgeArgs, forgeEnv, l1ContractsPath);
+  const result = await runProcess<ForgeRollupUpgradeResult>(
+    process.execPath,
+    [scriptPath, ...forgeArgs],
+    forgeEnv,
+    l1ContractsPath,
+  );
   if (!result) {
     throw new Error('Forge script did not output deployment result');
   }

package/src/generated/l1-contracts-defaults.ts

@@ -0,0 +1,32 @@
+// Auto-generated from spartan/environments/network-defaults.yml
+// Do not edit manually - run yarn generate to regenerate
+
+/** Default L1 contracts configuration values from network-defaults.yml */
+export const l1ContractsDefaultEnv = {
+  ETHEREUM_SLOT_DURATION: 12,
+  AZTEC_SLOT_DURATION: 36,
+  AZTEC_EPOCH_DURATION: 32,
+  AZTEC_TARGET_COMMITTEE_SIZE: 48,
+  AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2,
+  AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 2,
+  AZTEC_ACTIVATION_THRESHOLD: 100000000000000000000,
+  AZTEC_EJECTION_THRESHOLD: 50000000000000000000,
+  AZTEC_LOCAL_EJECTION_THRESHOLD: 98000000000000000000,
+  AZTEC_EXIT_DELAY_SECONDS: 172800,
+  AZTEC_INBOX_LAG: 1,
+  AZTEC_PROOF_SUBMISSION_EPOCHS: 1,
+  AZTEC_MANA_TARGET: 100000000,
+  AZTEC_PROVING_COST_PER_MANA: 100,
+  AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000,
+  AZTEC_SLASHER_FLAVOR: 'tally',
+  AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4,
+  AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 5,
+  AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS: 0,
+  AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2,
+  AZTEC_SLASHING_VETOER: '0x0000000000000000000000000000000000000000',
+  AZTEC_SLASHING_DISABLE_DURATION: 432000,
+  AZTEC_SLASH_AMOUNT_SMALL: 10000000000000000000,
+  AZTEC_SLASH_AMOUNT_MEDIUM: 20000000000000000000,
+  AZTEC_SLASH_AMOUNT_LARGE: 50000000000000000000,
+  AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 300,
+} as const;

package/src/l1_tx_utils/constants.ts

@@ -3,8 +3,8 @@
 // 1_000_000_000_000_000_000 Wei = 1 ETH
 export const WEI_CONST = 1_000_000_000n;
 
-// @note using this large gas limit to avoid the issue of `gas limit too low` when estimating gas in reth
-export const LARGE_GAS_LIMIT = 12_000_000n;
+// EIP-7825: protocol-level cap on tx gas limit (2^24). Clients reject above this.
+export const MAX_L1_TX_LIMIT = 16_777_216n;
 
 // setting a minimum bump percentage to 10% due to geth's implementation
 // https://github.com/ethereum/go-ethereum/blob/e3d61e6db028c412f74bc4d4c7e117a9e29d0de0/core/txpool/legacypool/list.go#L298

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

@@ -134,7 +134,7 @@ export const P75AllTxsPriorityFeeStrategy: PriorityFeeStrategy = {
     // Sanity check: cap competitive fee at 100x network estimate to avoid using unrealistic fees
     const maxReasonableFee = networkEstimate * 100n;
     if (competitiveFee > maxReasonableFee && networkEstimate > 0n) {
-      logger?.warn('Competitive fee exceeds sanity cap, using capped value', {
+      logger?.debug('Competitive fee exceeds sanity cap, using capped value', {
         competitiveFee: formatGwei(competitiveFee),
         networkEstimate: formatGwei(networkEstimate),
         cappedTo: formatGwei(maxReasonableFee),

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

@@ -207,7 +207,7 @@ export const P75BlobTxsOnlyPriorityFeeStrategy: PriorityFeeStrategy = {
 
         // 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)),
           });

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,
@@ -249,7 +249,7 @@ export class ReadOnlyL1TxUtils {
         ...request,
         ..._blobInputs,
         maxFeePerBlobGas: gasPrice.maxFeePerBlobGas!,
-        gas: LARGE_GAS_LIMIT,
+        gas: MAX_L1_TX_LIMIT,
         blockTag: 'latest',
       });
 
@@ -258,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}`);

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,6 +1,6 @@
 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';
@@ -99,6 +99,7 @@ export async function getL1ContractsConfig(
     inboxLag: Number(inboxLag),
     governanceProposerQuorum: Number(governanceProposerQuorum),
     governanceProposerRoundSize: Number(governanceProposerRoundSize),
+    governanceVotingDuration: DefaultL1ContractsConfig.governanceVotingDuration,
     activationThreshold,
     ejectionThreshold,
     localEjectionThreshold,
@@ -118,5 +119,6 @@ export async function getL1ContractsConfig(
     slashAmountSmall: slashingAmounts[0],
     slashAmountMedium: slashingAmounts[1],
     slashAmountLarge: slashingAmounts[2],
+    initialEthPerFeeAsset: DefaultL1ContractsConfig.initialEthPerFeeAsset,
   };
 }

package/src/test/rollup_cheat_codes.ts

@@ -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;

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/utils.ts

@@ -4,6 +4,7 @@ import { ErrorsAbi } from '@aztec/l1-artifacts/ErrorsAbi';
 
 import {
   type Abi,
+  type AbiItem,
   BaseError,
   type ContractEventName,
   ContractFunctionRevertedError,
@@ -14,6 +15,7 @@ import {
   decodeErrorResult,
   decodeEventLog,
 } from 'viem';
+import { formatAbiItem, formatAbiParams } from 'viem/utils';
 
 export interface L2Claim {
   claimSecret: Fr;
@@ -93,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) {