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

package/src/contracts/rollup.ts

@@ -3,7 +3,6 @@ import { EthAddress } from '@aztec/foundation/eth-address';
 import type { ViemSignature } from '@aztec/foundation/eth-signature';
 import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
 import { RollupStorage } from '@aztec/l1-artifacts/RollupStorage';
-import { SlasherAbi } from '@aztec/l1-artifacts/SlasherAbi';
 
 import chunk from 'lodash.chunk';
 import {
@@ -11,8 +10,8 @@ import {
   type GetContractReturnType,
   type Hex,
   type StateOverride,
+  type WatchContractEventReturnType,
   encodeFunctionData,
-  getAddress,
   getContract,
   hexToBigInt,
   keccak256,
@@ -160,13 +159,12 @@ export class RollupContract {
   public async getSlashingProposer(): Promise<
     EmpireSlashingProposerContract | TallySlashingProposerContract | undefined
   > {
-    const slasherAddress = await this.rollup.read.getSlasher();
-    if (EthAddress.fromString(slasherAddress).isZero()) {
+    const slasher = await this.getSlasherContract();
+    if (!slasher) {
       return undefined;
     }
 
-    const slasher = getContract({ address: slasherAddress, abi: SlasherAbi, client: this.client });
-    const proposerAddress = await slasher.read.PROPOSER();
+    const proposerAddress = await slasher.getProposer();
     const proposerAbi = [
       {
         type: 'function',
@@ -177,7 +175,7 @@ export class RollupContract {
       },
     ] as const;
 
-    const proposer = getContract({ address: proposerAddress, abi: proposerAbi, client: this.client });
+    const proposer = getContract({ address: proposerAddress.toString(), abi: proposerAbi, client: this.client });
     const proposerType = await proposer.read.SLASHING_PROPOSER_TYPE();
     if (proposerType === SlashingProposerType.Tally.valueOf()) {
       return new TallySlashingProposerContract(this.client, proposerAddress);
@@ -223,6 +221,16 @@ export class RollupContract {
     return this.rollup.read.getEjectionThreshold();
   }
 
+  @memoize
+  getLocalEjectionThreshold() {
+    return this.rollup.read.getLocalEjectionThreshold();
+  }
+
+  @memoize
+  getLagInEpochs() {
+    return this.rollup.read.getLagInEpochs();
+  }
+
   @memoize
   getActivationThreshold() {
     return this.rollup.read.getActivationThreshold();
@@ -293,16 +301,19 @@ export class RollupContract {
     };
   }
 
-  getSlasher() {
+  getSlasherAddress() {
     return this.rollup.read.getSlasher();
   }
 
   /**
    * Returns a SlasherContract instance for interacting with the slasher contract.
    */
-  async getSlasherContract(): Promise<SlasherContract> {
-    const slasherAddress = await this.getSlasher();
-    return new SlasherContract(this.client, EthAddress.fromString(slasherAddress));
+  async getSlasherContract(): Promise<SlasherContract | undefined> {
+    const slasherAddress = EthAddress.fromString(await this.getSlasherAddress());
+    if (slasherAddress.isZero()) {
+      return undefined;
+    }
+    return new SlasherContract(this.client, slasherAddress);
   }
 
   getOwner() {
@@ -314,13 +325,11 @@ export class RollupContract {
   }
 
   public async getSlashingProposerAddress() {
-    const slasherAddress = await this.getSlasher();
-    const slasher = getContract({
-      address: getAddress(slasherAddress.toString()),
-      abi: SlasherAbi,
-      client: this.client,
-    });
-    return EthAddress.fromString(await slasher.read.PROPOSER());
+    const slasher = await this.getSlasherContract();
+    if (!slasher) {
+      return EthAddress.ZERO;
+    }
+    return await slasher.getProposer();
   }
 
   getBlockReward() {
@@ -433,8 +442,15 @@ export class RollupContract {
     return this.rollup.read.getEntryQueueLength();
   }
 
-  async getEpochNumber(blockNumber?: bigint) {
-    blockNumber ??= await this.getBlockNumber();
+  getNextFlushableEpoch() {
+    return this.rollup.read.getNextFlushableEpoch();
+  }
+
+  getCurrentEpochNumber(): Promise<bigint> {
+    return this.rollup.read.getCurrentEpoch();
+  }
+
+  getEpochNumberForBlock(blockNumber: bigint) {
     return this.rollup.read.getEpochForBlock([BigInt(blockNumber)]);
   }
 
@@ -719,7 +735,9 @@ export class RollupContract {
     });
   }
 
-  public listenToSlasherChanged(callback: (args: { oldSlasher: `0x${string}`; newSlasher: `0x${string}` }) => unknown) {
+  public listenToSlasherChanged(
+    callback: (args: { oldSlasher: `0x${string}`; newSlasher: `0x${string}` }) => unknown,
+  ): WatchContractEventReturnType {
     return this.rollup.watchEvent.SlasherUpdated(
       {},
       {
@@ -735,6 +753,22 @@ export class RollupContract {
     );
   }
 
+  public listenToBlockInvalidated(callback: (args: { blockNumber: bigint }) => unknown): WatchContractEventReturnType {
+    return this.rollup.watchEvent.BlockInvalidated(
+      {},
+      {
+        onLogs: logs => {
+          for (const log of logs) {
+            const args = log.args;
+            if (args.blockNumber !== undefined) {
+              callback({ blockNumber: args.blockNumber });
+            }
+          }
+        },
+      },
+    );
+  }
+
   public async getSlashEvents(l1BlockHash: Hex): Promise<{ amount: bigint; attester: EthAddress }[]> {
     const events = await this.rollup.getEvents.Slashed({}, { blockHash: l1BlockHash, strict: true });
     return events.map(event => ({
@@ -743,7 +777,9 @@ export class RollupContract {
     }));
   }
 
-  public listenToSlash(callback: (args: { amount: bigint; attester: EthAddress }) => unknown) {
+  public listenToSlash(
+    callback: (args: { amount: bigint; attester: EthAddress }) => unknown,
+  ): WatchContractEventReturnType {
     return this.rollup.watchEvent.Slashed(
       {},
       {

package/src/deploy_l1_contracts.ts

@@ -5,6 +5,7 @@ import { EthAddress } from '@aztec/foundation/eth-address';
 import type { Fr } from '@aztec/foundation/fields';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 import { type Logger, createLogger } from '@aztec/foundation/log';
+import { retryUntil } from '@aztec/foundation/retry';
 import { DateProvider } from '@aztec/foundation/timer';
 import type { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
 
@@ -33,7 +34,6 @@ import { createExtendedL1Client } from './client.js';
 import {
   type L1ContractsConfig,
   getEntryQueueConfig,
-  getGSEConfiguration,
   getGovernanceConfiguration,
   getRewardBoostConfig,
   getRewardConfig,
@@ -193,13 +193,11 @@ export const deploySharedContracts = async (
   const stakingAssetAddress = await deployer.deploy(StakingAssetArtifact, ['Staking', 'STK', l1Client.account.address]);
   logger.verbose(`Deployed Staking Asset at ${stakingAssetAddress}`);
 
-  const gseConfiguration = getGSEConfiguration(networkName);
-
   const gseAddress = await deployer.deploy(GSEArtifact, [
     l1Client.account.address,
     stakingAssetAddress.toString(),
-    gseConfiguration.activationThreshold,
-    gseConfiguration.ejectionThreshold,
+    args.activationThreshold,
+    args.ejectionThreshold,
   ]);
   logger.verbose(`Deployed GSE at ${gseAddress}`);
 
@@ -433,6 +431,7 @@ export const deployRollupForUpgrade = async (
   registryAddress: EthAddress,
   logger: Logger,
   txUtilsConfig: L1TxUtilsConfig,
+  flushEntryQueue: boolean = true,
 ) => {
   const deployer = new L1Deployer(
     extendedClient,
@@ -445,7 +444,14 @@ export const deployRollupForUpgrade = async (
 
   const addresses = await RegistryContract.collectAddresses(extendedClient, registryAddress, 'canonical');
 
-  const { rollup, slashFactoryAddress } = await deployRollup(extendedClient, deployer, args, addresses, logger);
+  const { rollup, slashFactoryAddress } = await deployRollup(
+    extendedClient,
+    deployer,
+    args,
+    addresses,
+    flushEntryQueue,
+    logger,
+  );
 
   await deployer.waitForDeployments();
 
@@ -504,6 +510,7 @@ export const deployRollup = async (
     | 'gseAddress'
     | 'governanceAddress'
   >,
+  flushEntryQueue: boolean,
   logger: Logger,
 ) => {
   if (!addresses.gseAddress) {
@@ -533,6 +540,7 @@ export const deployRollup = async (
     aztecSlotDuration: BigInt(args.aztecSlotDuration),
     aztecEpochDuration: BigInt(args.aztecEpochDuration),
     targetCommitteeSize: BigInt(args.aztecTargetCommitteeSize),
+    lagInEpochs: BigInt(args.lagInEpochs),
     aztecProofSubmissionEpochs: BigInt(args.aztecProofSubmissionEpochs),
     slashingQuorum: BigInt(args.slashingQuorum ?? (args.slashingRoundSizeInEpochs * args.aztecEpochDuration) / 2 + 1),
     slashingRoundSize: BigInt(args.slashingRoundSizeInEpochs * args.aztecEpochDuration),
@@ -549,6 +557,7 @@ export const deployRollup = async (
     slasherFlavor: slasherFlavorToSolidityEnum(args.slasherFlavor),
     slashingOffsetInRounds: BigInt(args.slashingOffsetInRounds),
     slashAmounts: [args.slashAmountSmall, args.slashAmountMedium, args.slashAmountLarge],
+    localEjectionThreshold: args.localEjectionThreshold,
   };
 
   const genesisStateArgs = {
@@ -676,6 +685,7 @@ export const deployRollup = async (
       addresses.stakingAssetAddress.toString(),
       args.initialValidators,
       args.acceleratedTestDeployments,
+      flushEntryQueue,
       logger,
     );
   }
@@ -852,6 +862,7 @@ export const addMultipleValidators = async (
   stakingAssetAddress: Hex,
   validators: Operator[],
   acceleratedTestDeployments: boolean | undefined,
+  flushEntryQueue: boolean,
   logger: Logger,
 ) => {
   const rollup = new RollupContract(extendedClient, rollupAddress);
@@ -918,7 +929,7 @@ export const addMultipleValidators = async (
             data: encodeFunctionData({
               abi: MultiAdderArtifact.contractAbi,
               functionName: 'addValidators',
-              args: [validatorsTuples, true],
+              args: [validatorsTuples, /* skip flushing */ true],
             }),
           },
           {
@@ -926,19 +937,49 @@ export const addMultipleValidators = async (
           },
         );
 
-        await deployer.l1TxUtils.sendAndMonitorTransaction(
-          {
-            to: rollupAddress,
-            data: encodeFunctionData({
-              abi: RollupArtifact.contractAbi,
-              functionName: 'flushEntryQueue',
-              args: [],
-            }),
-          },
-          {
-            gasLimit: 40_000_000n,
-          },
-        );
+        let queueLength = await rollup.getEntryQueueLength();
+        while (flushEntryQueue && queueLength > 0n) {
+          logger.info(`Flushing entry queue with ${queueLength} entries`);
+
+          try {
+            await deployer.l1TxUtils.sendAndMonitorTransaction(
+              {
+                to: rollupAddress,
+                data: encodeFunctionData({
+                  abi: RollupArtifact.contractAbi,
+                  functionName: 'flushEntryQueue',
+                  args: [],
+                }),
+              },
+              {
+                gasLimit: 20_000_000n,
+              },
+            );
+          } catch (err) {
+            logger.warn('Failed to flush queue', { err });
+          }
+
+          queueLength = await rollup.getEntryQueueLength();
+          // check if we drained the queue enough here so we can avoid sleep
+          if (queueLength === 0n) {
+            break;
+          }
+
+          logger.info(`Waiting for next flushable epoch to flush remaining ${queueLength} entries`);
+          await retryUntil(
+            async () => {
+              const [currentEpoch, flushableEpoch] = await Promise.all([
+                rollup.getCurrentEpochNumber(),
+                rollup.getNextFlushableEpoch(),
+              ]);
+              logger.debug(`Next flushable epoch is ${flushableEpoch} (current epoch is ${currentEpoch})`);
+              return currentEpoch >= flushableEpoch;
+            },
+            'wait for next flushable epoch',
+            3600,
+            12,
+          );
+        }
       } else {
         await deployer.l1TxUtils.sendAndMonitorTransaction(
           {
@@ -946,7 +987,7 @@ export const addMultipleValidators = async (
             data: encodeFunctionData({
               abi: MultiAdderArtifact.contractAbi,
               functionName: 'addValidators',
-              args: [validatorsTuples, false],
+              args: [validatorsTuples, /* skip flushing */ !flushEntryQueue],
             }),
           },
           {
@@ -1029,6 +1070,7 @@ export const deployL1Contracts = async (
   args: DeployL1ContractsArgs,
   txUtilsConfig: L1TxUtilsConfig = getL1TxUtilsConfigEnvVars(),
   createVerificationJson: string | false = false,
+  flushEntryQueue: boolean = true,
 ): Promise<DeployL1ContractsReturnType> => {
   logger.info(`Deploying L1 contracts with config: ${jsonStringify(args)}`);
   validateConfig(args);
@@ -1095,6 +1137,7 @@ export const deployL1Contracts = async (
       stakingAssetAddress,
       governanceAddress,
     },
+    flushEntryQueue,
     logger,
   );
 
@@ -1145,7 +1188,7 @@ export const deployL1Contracts = async (
 
       // Include Slasher and SlashingProposer (if deployed) in verification data
       try {
-        const slasherAddrHex = await rollup.getSlasher();
+        const slasherAddrHex = await rollup.getSlasherAddress();
         const slasherAddr = EthAddress.fromString(slasherAddrHex);
         if (!slasherAddr.isZero()) {
           // Slasher constructor: (address _vetoer, address _governance)

package/src/l1_tx_utils.ts

@@ -279,7 +279,13 @@ export class ReadOnlyL1TxUtils {
     let blobBaseFee = 0n;
     if (isBlobTx) {
       try {
-        blobBaseFee = await this.client.getBlobBaseFee();
+        blobBaseFee = await retry<bigint>(
+          () => this.client.getBlobBaseFee(),
+          'Getting L1 blob base fee',
+          makeBackoff(times(2, () => 1)),
+          this.logger,
+          true,
+        );
         this.logger?.debug('L1 Blob base fee:', { blobBaseFee: formatGwei(blobBaseFee) });
       } catch {
         this.logger?.warn('Failed to get L1 blob base fee', attempt);
@@ -706,12 +712,14 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
    * Monitors a transaction until completion, handling speed-ups if needed
    * @param request - Original transaction request (needed for speed-ups)
    * @param initialTxHash - Hash of the initial transaction
+   * @param allVersions - Hashes of all transactions submitted under the same nonce (any of them could mine)
    * @param params - Parameters used in the initial transaction
    * @param gasConfig - Optional gas configuration
    */
   public async monitorTransaction(
     request: L1TxRequest,
     initialTxHash: Hex,
+    allVersions: Set<Hex>,
     params: { gasLimit: bigint },
     _gasConfig?: Partial<L1TxUtilsConfig> & { txTimeoutAt?: Date },
     _blobInputs?: L1BlobInputs,
@@ -743,7 +751,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
     }
     const nonce = tx.nonce;
 
-    const txHashes = new Set<Hex>([initialTxHash]);
+    allVersions.add(initialTxHash);
     let currentTxHash = initialTxHash;
     let attempts = 0;
     let lastAttemptSent = this.dateProvider.now();
@@ -776,8 +784,9 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
         }));
 
         const currentNonce = await this.client.getTransactionCount({ address: account });
+        // If the current nonce on our account is greater than our transaction's nonce then a tx with the same nonce has been mined.
         if (currentNonce > nonce) {
-          for (const hash of txHashes) {
+          for (const hash of allVersions) {
             try {
               const receipt = await this.client.getTransactionReceipt({ hash });
               if (receipt) {
@@ -796,6 +805,10 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
               }
             }
           }
+          // If we get here then we have checked all of our tx versions and not found anything.
+          // We should consider the nonce as MINED
+          this.state = TxUtilsState.MINED;
+          throw new Error(`Nonce ${nonce} is MINED but not by one of our expected transactions`);
         }
 
         this.logger?.trace(`Tx timeout check for ${currentTxHash}: ${isTimedOut()}`, {
@@ -857,7 +870,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
             },
           );
 
-          const txData = {
+          const txData: PrepareTransactionRequestRequest = {
             ...request,
             ...blobInputs,
             nonce,
@@ -865,6 +878,9 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
             maxFeePerGas: newGasPrice.maxFeePerGas,
             maxPriorityFeePerGas: newGasPrice.maxPriorityFeePerGas,
           };
+          if (isBlobTx && newGasPrice.maxFeePerBlobGas) {
+            (txData as any).maxFeePerBlobGas = newGasPrice.maxFeePerBlobGas;
+          }
           const signedRequest = await this.prepareSignedTransaction(txData);
           const newHash = await this.client.sendRawTransaction({ serializedTransaction: signedRequest });
           if (!isCancelTx) {
@@ -882,7 +898,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
 
           currentTxHash = newHash;
 
-          txHashes.add(currentTxHash);
+          allVersions.add(currentTxHash);
           lastAttemptSent = this.dateProvider.now();
         }
         await sleep(gasConfig.checkIntervalMs!);
@@ -904,7 +920,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
       this.state = TxUtilsState.NOT_MINED;
     } else if (gasConfig.cancelTxOnTimeout) {
       // Fire cancellation without awaiting to avoid blocking the main thread
-      this.attemptTxCancellation(currentTxHash, nonce, isBlobTx, lastGasPrice, attempts).catch(err => {
+      this.attemptTxCancellation(currentTxHash, nonce, allVersions, isBlobTx, lastGasPrice, attempts).catch(err => {
         const viemError = formatViemError(err);
         this.logger?.error(`Failed to send cancellation for timed out tx ${currentTxHash}:`, viemError.message, {
           metaMessages: viemError.metaMessages,
@@ -938,7 +954,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
     blobInputs?: L1BlobInputs,
   ): Promise<{ receipt: TransactionReceipt; gasPrice: GasPrice }> {
     const { txHash, gasLimit, gasPrice } = await this.sendTransaction(request, gasConfig, blobInputs);
-    const receipt = await this.monitorTransaction(request, txHash, { gasLimit }, gasConfig, blobInputs);
+    const receipt = await this.monitorTransaction(request, txHash, new Set(), { gasLimit }, gasConfig, blobInputs);
     return { receipt, gasPrice };
   }
 
@@ -973,6 +989,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
   /**
    * Attempts to cancel a transaction by sending a 0-value tx to self with same nonce but higher gas prices
    * @param nonce - The nonce of the transaction to cancel
+   * @param allVersions - Hashes of all transactions submitted under the same nonce (any of them could mine)
    * @param previousGasPrice - The gas price of the previous transaction
    * @param attempts - The number of attempts to cancel the transaction
    * @returns The hash of the cancellation transaction
@@ -980,6 +997,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
   protected async attemptTxCancellation(
     currentTxHash: Hex,
     nonce: number,
+    allVersions: Set<Hex>,
     isBlobTx = false,
     previousGasPrice?: GasPrice,
     attempts = 0,
@@ -1000,7 +1018,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
       previousGasPrice,
     );
 
-    this.logger?.debug(`Attempting to cancel L1 transaction ${currentTxHash} with nonce ${nonce}`, {
+    this.logger?.info(`Attempting to cancel L1 transaction ${currentTxHash} with nonce ${nonce}`, {
       maxFeePerGas: formatGwei(cancelGasPrice.maxFeePerGas),
       maxPriorityFeePerGas: formatGwei(cancelGasPrice.maxPriorityFeePerGas),
     });
@@ -1022,11 +1040,12 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
 
     this.state = TxUtilsState.CANCELLED;
 
-    this.logger?.debug(`Sent cancellation tx ${cancelTxHash} for timed out tx ${currentTxHash}`, { nonce });
+    this.logger?.info(`Sent cancellation tx ${cancelTxHash} for timed out tx ${currentTxHash}`, { nonce });
 
     const receipt = await this.monitorTransaction(
       request,
       cancelTxHash,
+      allVersions,
       { gasLimit: 21_000n },
       undefined,
       undefined,

package/src/l1_tx_utils_with_blobs.ts

@@ -19,6 +19,7 @@ export class L1TxUtilsWithBlobs extends L1TxUtils {
   /**
    * Attempts to cancel a transaction by sending a 0-value tx to self with same nonce but higher gas prices
    * @param nonce - The nonce of the transaction to cancel
+   * @param allVersions - Hashes of all transactions submitted under the same nonce (any of them could mine)
    * @param previousGasPrice - The gas price of the previous transaction
    * @param attempts - The number of attempts to cancel the transaction
    * @returns The hash of the cancellation transaction
@@ -26,6 +27,7 @@ export class L1TxUtilsWithBlobs extends L1TxUtils {
   override async attemptTxCancellation(
     currentTxHash: Hex,
     nonce: number,
+    allVersions: Set<Hex>,
     isBlobTx = false,
     previousGasPrice?: GasPrice,
     attempts = 0,
@@ -42,7 +44,7 @@ export class L1TxUtilsWithBlobs extends L1TxUtils {
       previousGasPrice,
     );
 
-    this.logger?.debug(`Attempting to cancel blob L1 transaction ${currentTxHash} with nonce ${nonce}`, {
+    this.logger?.info(`Attempting to cancel blob L1 transaction ${currentTxHash} with nonce ${nonce}`, {
       maxFeePerGas: formatGwei(cancelGasPrice.maxFeePerGas),
       maxPriorityFeePerGas: formatGwei(cancelGasPrice.maxPriorityFeePerGas),
       maxFeePerBlobGas:
@@ -65,9 +67,12 @@ export class L1TxUtilsWithBlobs extends L1TxUtils {
       const signedRequest = await this.prepareSignedTransaction(txData);
       const cancelTxHash = await this.client.sendRawTransaction({ serializedTransaction: signedRequest });
 
+      this.logger?.info(`Sent cancellation tx ${cancelTxHash} for timed out tx ${currentTxHash}`);
+
       const receipt = await this.monitorTransaction(
         request,
         cancelTxHash,
+        allVersions,
         { gasLimit: 21_000n },
         undefined,
         undefined,
@@ -94,11 +99,12 @@ export class L1TxUtilsWithBlobs extends L1TxUtils {
       const signedRequest = await this.prepareSignedTransaction(txData);
       const cancelTxHash = await this.client.sendRawTransaction({ serializedTransaction: signedRequest });
 
-      this.logger?.debug(`Sent cancellation tx ${cancelTxHash} for timed out tx ${currentTxHash}`);
+      this.logger?.info(`Sent cancellation tx ${cancelTxHash} for timed out tx ${currentTxHash}`);
 
       const receipt = await this.monitorTransaction(
         request,
         cancelTxHash,
+        allVersions,
         { gasLimit: 21_000n },
         undefined,
         blobInputs,

package/src/queries.ts

@@ -1,7 +1,4 @@
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { SlasherAbi } from '@aztec/l1-artifacts/SlasherAbi';
-
-import { getContract } from 'viem';
 
 import type { L1ContractsConfig } from './config.js';
 import { ReadOnlyGovernanceContract } from './contracts/governance.js';
@@ -27,8 +24,7 @@ export async function getL1ContractsConfig(
   const rollupAddress = addresses.rollupAddress ?? (await governanceProposer.getRollupAddress());
   const rollup = new RollupContract(publicClient, rollupAddress.toString());
   const slasherProposer = await rollup.getSlashingProposer();
-  const slasherAddress = await rollup.getSlasher();
-  const slasher = getContract({ address: slasherAddress, abi: SlasherAbi, client: publicClient });
+  const slasher = await rollup.getSlasherContract();
 
   const [
     l1StartBlock,
@@ -37,8 +33,10 @@ export async function getL1ContractsConfig(
     aztecSlotDuration,
     aztecProofSubmissionEpochs,
     aztecTargetCommitteeSize,
+    lagInEpochs,
     activationThreshold,
     ejectionThreshold,
+    localEjectionThreshold,
     governanceProposerQuorum,
     governanceProposerRoundSize,
     slashingQuorum,
@@ -60,8 +58,10 @@ export async function getL1ContractsConfig(
     rollup.getSlotDuration(),
     rollup.getProofSubmissionEpochs(),
     rollup.getTargetCommitteeSize(),
+    rollup.getLagInEpochs(),
     rollup.getActivationThreshold(),
     rollup.getEjectionThreshold(),
+    rollup.getLocalEjectionThreshold(),
     governanceProposer.getQuorumSize(),
     governanceProposer.getRoundSize(),
     slasherProposer?.getQuorumSize() ?? 0n,
@@ -70,7 +70,7 @@ export async function getL1ContractsConfig(
     slasherProposer?.getExecutionDelayInRounds() ?? 0n,
     slasherProposer?.type === 'tally' ? slasherProposer.getSlashOffsetInRounds() : 0n,
     slasherProposer?.type === 'tally' ? slasherProposer.getSlashingAmounts() : [0n, 0n, 0n],
-    slasher.read.VETOER(),
+    slasher?.getVetoer() ?? EthAddress.ZERO,
     rollup.getManaTarget(),
     rollup.getProvingCostPerMana(),
     rollup.getVersion(),
@@ -85,15 +85,17 @@ export async function getL1ContractsConfig(
     aztecSlotDuration: Number(aztecSlotDuration),
     aztecProofSubmissionEpochs: Number(aztecProofSubmissionEpochs),
     aztecTargetCommitteeSize: Number(aztecTargetCommitteeSize),
+    lagInEpochs: Number(lagInEpochs),
     governanceProposerQuorum: Number(governanceProposerQuorum),
     governanceProposerRoundSize: Number(governanceProposerRoundSize),
     activationThreshold,
     ejectionThreshold,
+    localEjectionThreshold,
     slashingQuorum: Number(slashingQuorum),
     slashingRoundSizeInEpochs: Number(slashingRoundSize / aztecEpochDuration),
     slashingLifetimeInRounds: Number(slashingLifetimeInRounds),
     slashingExecutionDelayInRounds: Number(slashingExecutionDelayInRounds),
-    slashingVetoer: EthAddress.fromString(slashingVetoer),
+    slashingVetoer,
     manaTarget: manaTarget,
     provingCostPerMana: provingCostPerMana,
     rollupVersion: Number(rollupVersion),