@aztec/ethereum 2.0.0-nightly.20250903 → 3.0.0-canary.a9708bd

package/src/config.ts

@@ -423,78 +423,7 @@ export function validateConfig(config: Omit<L1ContractsConfig, keyof L1TxUtilsCo
 
   // TallySlashingProposer constructor validations
   if (config.slasherFlavor === 'tally') {
-    // From: require(SLASH_OFFSET_IN_ROUNDS > 0, Errors.TallySlashingProposer__SlashOffsetMustBeGreaterThanZero(...));
-    if (config.slashingOffsetInRounds <= 0) {
-      errors.push(`slashingOffsetInRounds (${config.slashingOffsetInRounds}) must be greater than 0`);
-    }
-
-    // From: require(ROUND_SIZE_IN_EPOCHS * _epochDuration == ROUND_SIZE, Errors.TallySlashingProposer__RoundSizeMustBeMultipleOfEpochDuration(...));
-    const roundSizeInSlots = config.slashingRoundSizeInEpochs * config.aztecEpochDuration;
-
-    // From: require(QUORUM > 0, Errors.TallySlashingProposer__QuorumMustBeGreaterThanZero());
-    if (slashingQuorum !== undefined && slashingQuorum <= 0) {
-      errors.push(`slashingQuorum (${slashingQuorum}) must be greater than 0`);
-    }
-
-    // From: require(ROUND_SIZE > 1, Errors.TallySlashingProposer__InvalidQuorumAndRoundSize(QUORUM, ROUND_SIZE));
-    if (roundSizeInSlots <= 1) {
-      errors.push(`slashing round size in slots (${roundSizeInSlots}) must be greater than 1`);
-    }
-
-    // From: require(_slashAmounts[0] <= _slashAmounts[1], Errors.TallySlashingProposer__InvalidSlashAmounts(_slashAmounts));
-    if (config.slashAmountSmall > config.slashAmountMedium) {
-      errors.push(
-        `slashAmountSmall (${config.slashAmountSmall}) must be less than or equal to slashAmountMedium (${config.slashAmountMedium})`,
-      );
-    }
-
-    // From: require(_slashAmounts[1] <= _slashAmounts[2], Errors.TallySlashingProposer__InvalidSlashAmounts(_slashAmounts));
-    if (config.slashAmountMedium > config.slashAmountLarge) {
-      errors.push(
-        `slashAmountMedium (${config.slashAmountMedium}) must be less than or equal to slashAmountLarge (${config.slashAmountLarge})`,
-      );
-    }
-
-    // From: require(LIFETIME_IN_ROUNDS < ROUNDABOUT_SIZE, Errors.TallySlashingProposer__LifetimeMustBeLessThanRoundabout(...));
-    const ROUNDABOUT_SIZE = 128; // Constant from TallySlashingProposer
-    if (config.slashingLifetimeInRounds >= ROUNDABOUT_SIZE) {
-      errors.push(`slashingLifetimeInRounds (${config.slashingLifetimeInRounds}) must be less than ${ROUNDABOUT_SIZE}`);
-    }
-
-    // From: require(ROUND_SIZE_IN_EPOCHS > 0, Errors.TallySlashingProposer__RoundSizeInEpochsMustBeGreaterThanZero(...));
-    if (config.slashingRoundSizeInEpochs <= 0) {
-      errors.push(`slashingRoundSizeInEpochs (${config.slashingRoundSizeInEpochs}) must be greater than 0`);
-    }
-
-    // From: require(ROUND_SIZE < MAX_ROUND_SIZE, Errors.TallySlashingProposer__RoundSizeTooLarge(ROUND_SIZE, MAX_ROUND_SIZE));
-    const MAX_ROUND_SIZE = 1024; // Constant from TallySlashingProposer
-    if (roundSizeInSlots >= MAX_ROUND_SIZE) {
-      errors.push(`slashing round size in slots (${roundSizeInSlots}) must be less than ${MAX_ROUND_SIZE}`);
-    }
-
-    // From: require(COMMITTEE_SIZE > 0, Errors.TallySlashingProposer__CommitteeSizeMustBeGreaterThanZero(COMMITTEE_SIZE));
-    if (config.aztecTargetCommitteeSize <= 0) {
-      errors.push(`aztecTargetCommitteeSize (${config.aztecTargetCommitteeSize}) must be greater than 0`);
-    }
-
-    // From: require(voteSize <= 128, Errors.TallySlashingProposer__VoteSizeTooBig(voteSize, 128));
-    // voteSize = COMMITTEE_SIZE * ROUND_SIZE_IN_EPOCHS / 4
-    const voteSize = (config.aztecTargetCommitteeSize * config.slashingRoundSizeInEpochs) / 4;
-    if (voteSize > 128) {
-      errors.push(`vote size (${voteSize}) must be <= 128 (committee size * round size in epochs / 4)`);
-    }
-
-    // From: require(COMMITTEE_SIZE * ROUND_SIZE_IN_EPOCHS % 4 == 0, Errors.TallySlashingProposer__InvalidCommitteeAndRoundSize(...));
-    if ((config.aztecTargetCommitteeSize * config.slashingRoundSizeInEpochs) % 4 !== 0) {
-      errors.push(
-        `aztecTargetCommitteeSize * slashingRoundSizeInEpochs (${config.aztecTargetCommitteeSize * config.slashingRoundSizeInEpochs}) must be divisible by 4`,
-      );
-    }
-
-    // Slashing offset validation: should be positive to allow proper slashing timing
-    if (config.slashingOffsetInRounds < 0) {
-      errors.push('slashingOffsetInRounds cannot be negative');
-    }
+    validateTallySlasherConfig(config, errors);
   }
 
   // Epoch and slot duration validations
@@ -541,3 +470,83 @@ export function validateConfig(config: Omit<L1ContractsConfig, keyof L1TxUtilsCo
     );
   }
 }
+
+function validateTallySlasherConfig(config: L1ContractsConfig, errors: string[]) {
+  if (config.slasherFlavor !== 'tally') {
+    return;
+  }
+
+  // From: require(SLASH_OFFSET_IN_ROUNDS > 0, Errors.TallySlashingProposer__SlashOffsetMustBeGreaterThanZero(...));
+  if (config.slashingOffsetInRounds <= 0) {
+    errors.push(`slashingOffsetInRounds (${config.slashingOffsetInRounds}) must be greater than 0`);
+  }
+
+  // From: require(ROUND_SIZE_IN_EPOCHS * _epochDuration == ROUND_SIZE, Errors.TallySlashingProposer__RoundSizeMustBeMultipleOfEpochDuration(...));
+  const roundSizeInSlots = config.slashingRoundSizeInEpochs * config.aztecEpochDuration;
+
+  // From: require(QUORUM > 0, Errors.TallySlashingProposer__QuorumMustBeGreaterThanZero());
+  const { slashingQuorum } = config;
+  if (slashingQuorum !== undefined && slashingQuorum <= 0) {
+    errors.push(`slashingQuorum (${slashingQuorum}) must be greater than 0`);
+  }
+
+  // From: require(ROUND_SIZE > 1, Errors.TallySlashingProposer__InvalidQuorumAndRoundSize(QUORUM, ROUND_SIZE));
+  if (roundSizeInSlots <= 1) {
+    errors.push(`slashing round size in slots (${roundSizeInSlots}) must be greater than 1`);
+  }
+
+  // From: require(_slashAmounts[0] <= _slashAmounts[1], Errors.TallySlashingProposer__InvalidSlashAmounts(_slashAmounts));
+  if (config.slashAmountSmall > config.slashAmountMedium) {
+    errors.push(
+      `slashAmountSmall (${config.slashAmountSmall}) must be less than or equal to slashAmountMedium (${config.slashAmountMedium})`,
+    );
+  }
+
+  // From: require(_slashAmounts[1] <= _slashAmounts[2], Errors.TallySlashingProposer__InvalidSlashAmounts(_slashAmounts));
+  if (config.slashAmountMedium > config.slashAmountLarge) {
+    errors.push(
+      `slashAmountMedium (${config.slashAmountMedium}) must be less than or equal to slashAmountLarge (${config.slashAmountLarge})`,
+    );
+  }
+
+  // From: require(LIFETIME_IN_ROUNDS < ROUNDABOUT_SIZE, Errors.TallySlashingProposer__LifetimeMustBeLessThanRoundabout(...));
+  const ROUNDABOUT_SIZE = 128; // Constant from TallySlashingProposer
+  if (config.slashingLifetimeInRounds >= ROUNDABOUT_SIZE) {
+    errors.push(`slashingLifetimeInRounds (${config.slashingLifetimeInRounds}) must be less than ${ROUNDABOUT_SIZE}`);
+  }
+
+  // From: require(ROUND_SIZE_IN_EPOCHS > 0, Errors.TallySlashingProposer__RoundSizeInEpochsMustBeGreaterThanZero(...));
+  if (config.slashingRoundSizeInEpochs <= 0) {
+    errors.push(`slashingRoundSizeInEpochs (${config.slashingRoundSizeInEpochs}) must be greater than 0`);
+  }
+
+  // From: require(ROUND_SIZE < MAX_ROUND_SIZE, Errors.TallySlashingProposer__RoundSizeTooLarge(ROUND_SIZE, MAX_ROUND_SIZE));
+  const MAX_ROUND_SIZE = 1024; // Constant from TallySlashingProposer
+  if (roundSizeInSlots >= MAX_ROUND_SIZE) {
+    errors.push(`slashing round size in slots (${roundSizeInSlots}) must be less than ${MAX_ROUND_SIZE}`);
+  }
+
+  // From: require(COMMITTEE_SIZE > 0, Errors.TallySlashingProposer__CommitteeSizeMustBeGreaterThanZero(COMMITTEE_SIZE));
+  if (config.aztecTargetCommitteeSize <= 0) {
+    errors.push(`aztecTargetCommitteeSize (${config.aztecTargetCommitteeSize}) must be greater than 0`);
+  }
+
+  // From: require(voteSize <= 128, Errors.TallySlashingProposer__VoteSizeTooBig(voteSize, 128));
+  // voteSize = COMMITTEE_SIZE * ROUND_SIZE_IN_EPOCHS / 4
+  const voteSize = (config.aztecTargetCommitteeSize * config.slashingRoundSizeInEpochs) / 4;
+  if (voteSize > 128) {
+    errors.push(`vote size (${voteSize}) must be <= 128 (committee size * round size in epochs / 4)`);
+  }
+
+  // From: require(COMMITTEE_SIZE * ROUND_SIZE_IN_EPOCHS % 4 == 0, Errors.TallySlashingProposer__InvalidCommitteeAndRoundSize(...));
+  if ((config.aztecTargetCommitteeSize * config.slashingRoundSizeInEpochs) % 4 !== 0) {
+    errors.push(
+      `aztecTargetCommitteeSize * slashingRoundSizeInEpochs (${config.aztecTargetCommitteeSize * config.slashingRoundSizeInEpochs}) must be divisible by 4`,
+    );
+  }
+
+  // Slashing offset validation: should be positive to allow proper slashing timing
+  if (config.slashingOffsetInRounds < 0) {
+    errors.push('slashingOffsetInRounds cannot be negative');
+  }
+}

package/src/contracts/fee_asset_handler.ts

@@ -9,12 +9,24 @@ export class FeeAssetHandlerContract {
   public address: EthAddress;
 
   constructor(
-    address: Hex,
+    address: Hex | EthAddress,
     public readonly txUtils: L1TxUtils,
   ) {
+    if (address instanceof EthAddress) {
+      address = address.toString();
+    }
     this.address = EthAddress.fromString(address);
   }
 
+  public async getOwner(): Promise<EthAddress> {
+    const contract = getContract({
+      abi: FeeAssetHandlerAbi,
+      address: this.address.toString(),
+      client: this.txUtils.client,
+    });
+    return EthAddress.fromString(await contract.read.owner());
+  }
+
   public getMintAmount() {
     const contract = getContract({
       abi: FeeAssetHandlerAbi,
@@ -24,7 +36,10 @@ export class FeeAssetHandlerContract {
     return contract.read.mintAmount();
   }
 
-  public mint(recipient: Hex) {
+  public mint(recipient: Hex | EthAddress) {
+    if (recipient instanceof EthAddress) {
+      recipient = recipient.toString();
+    }
     return this.txUtils.sendAndMonitorTransaction({
       to: this.address.toString(),
       data: encodeFunctionData({

package/src/contracts/fee_juice.ts

@@ -9,9 +9,12 @@ export class FeeJuiceContract {
   private readonly feeJuiceContract: GetContractReturnType<typeof FeeJuiceAbi, ViemClient>;
 
   constructor(
-    address: Hex,
+    address: Hex | EthAddress,
     public readonly client: ViemClient,
   ) {
+    if (address instanceof EthAddress) {
+      address = address.toString();
+    }
     this.feeJuiceContract = getContract({ address, abi: FeeJuiceAbi, client });
   }
 
@@ -19,6 +22,10 @@ export class FeeJuiceContract {
     return EthAddress.fromString(this.feeJuiceContract.address);
   }
 
+  public async getOwner(): Promise<EthAddress> {
+    return EthAddress.fromString(await this.feeJuiceContract.read.owner());
+  }
+
   private assertWalletFeeJuice(): GetContractReturnType<typeof FeeJuiceAbi, ExtendedViemWalletClient> {
     if (!isExtendedClient(this.client)) {
       throw new Error('Wallet client is required for this operation');

package/src/contracts/governance.ts

@@ -136,9 +136,12 @@ export class GovernanceContract extends ReadOnlyGovernanceContract {
   protected override readonly governanceContract: GetContractReturnType<typeof GovernanceAbi, ExtendedViemWalletClient>;
 
   constructor(
-    address: Hex,
+    address: Hex | EthAddress,
     public override readonly client: ExtendedViemWalletClient,
   ) {
+    if (address instanceof EthAddress) {
+      address = address.toString();
+    }
     super(address, client);
     if (!isExtendedClient(client)) {
       throw new Error('GovernanceContract has to be instantiated with a wallet client.');

package/src/contracts/governance_proposer.ts

@@ -21,8 +21,11 @@ export class GovernanceProposerContract implements IEmpireBase {
 
   constructor(
     public readonly client: ViemClient,
-    address: Hex,
+    address: Hex | EthAddress,
   ) {
+    if (address instanceof EthAddress) {
+      address = address.toString();
+    }
     this.proposer = getContract({ address, abi: GovernanceProposerAbi, client });
   }
 

package/src/contracts/gse.ts

@@ -39,6 +39,14 @@ export class GSEContract {
     this.gse = getContract({ address, abi: GSEAbi, client });
   }
 
+  public async getOwner(): Promise<EthAddress> {
+    return EthAddress.fromString(await this.gse.read.owner());
+  }
+
+  public async getGovernance(): Promise<EthAddress> {
+    return EthAddress.fromString(await this.gse.read.getGovernance());
+  }
+
   getAttestersFromIndicesAtTime(instance: Hex | EthAddress, ts: bigint, indices: bigint[]) {
     if (instance instanceof EthAddress) {
       instance = instance.toString();

package/src/deploy_l1_contracts.ts

@@ -263,37 +263,14 @@ export const deploySharedContracts = async (
 
   const coinIssuerAddress = await deployer.deploy(CoinIssuerArtifact, [
     feeAssetAddress.toString(),
-    1n * 10n ** 18n, // @todo  #8084
-    governanceAddress.toString(),
+    1_000_000n * 10n ** 18n, // @todo  #8084
+    l1Client.account.address,
   ]);
   logger.verbose(`Deployed CoinIssuer at ${coinIssuerAddress}`);
 
-  const feeAsset = getContract({
-    address: feeAssetAddress.toString(),
-    abi: FeeAssetArtifact.contractAbi,
-    client: l1Client,
-  });
-
   logger.verbose(`Waiting for deployments to complete`);
   await deployer.waitForDeployments();
 
-  if (args.acceleratedTestDeployments || !(await feeAsset.read.minters([coinIssuerAddress.toString()]))) {
-    const { txHash } = await deployer.sendTransaction(
-      {
-        to: feeAssetAddress.toString(),
-        data: encodeFunctionData({
-          abi: FeeAssetArtifact.contractAbi,
-          functionName: 'addMinter',
-          args: [coinIssuerAddress.toString()],
-        }),
-      },
-      { gasLimit: 100_000n },
-    );
-
-    logger.verbose(`Added coin issuer ${coinIssuerAddress} as minter on fee asset in ${txHash}`);
-    txHashes.push(txHash);
-  }
-
   // Registry ownership will be transferred to governance later, after rollup is added
 
   let feeAssetHandlerAddress: EthAddress | undefined = undefined;
@@ -309,20 +286,23 @@ export const deploySharedContracts = async (
     feeAssetHandlerAddress = await deployer.deploy(FeeAssetHandlerArtifact, [
       l1Client.account.address,
       feeAssetAddress.toString(),
-      BigInt(1e18),
+      BigInt(1000n * 10n ** 18n),
     ]);
     logger.verbose(`Deployed FeeAssetHandler at ${feeAssetHandlerAddress}`);
 
-    const { txHash } = await deployer.sendTransaction({
-      to: feeAssetAddress.toString(),
-      data: encodeFunctionData({
-        abi: FeeAssetArtifact.contractAbi,
-        functionName: 'addMinter',
-        args: [feeAssetHandlerAddress.toString()],
-      }),
-    });
-    logger.verbose(`Added fee asset handler ${feeAssetHandlerAddress} as minter on fee asset in ${txHash}`);
-    txHashes.push(txHash);
+    // Only if we are "fresh" will we be adding as a minter, otherwise above will simply get same address
+    if (needToSetGovernance) {
+      const { txHash } = await deployer.sendTransaction({
+        to: feeAssetAddress.toString(),
+        data: encodeFunctionData({
+          abi: FeeAssetArtifact.contractAbi,
+          functionName: 'addMinter',
+          args: [feeAssetHandlerAddress.toString()],
+        }),
+      });
+      logger.verbose(`Added fee asset handler ${feeAssetHandlerAddress} as minter on fee asset in ${txHash}`);
+      txHashes.push(txHash);
+    }
 
     // Only if on sepolia will we deploy the staking asset handler
     // Should not be deployed to devnet since it would cause caos with sequencers there etc.
@@ -517,7 +497,12 @@ export const deployRollup = async (
   >,
   addresses: Pick<
     L1ContractAddresses,
-    'feeJuiceAddress' | 'registryAddress' | 'rewardDistributorAddress' | 'stakingAssetAddress' | 'gseAddress'
+    | 'feeJuiceAddress'
+    | 'registryAddress'
+    | 'rewardDistributorAddress'
+    | 'stakingAssetAddress'
+    | 'gseAddress'
+    | 'governanceAddress'
   >,
   logger: Logger,
 ) => {
@@ -695,6 +680,24 @@ export const deployRollup = async (
     );
   }
 
+  // If the owner is not the Governance contract, transfer ownership to the Governance contract
+  logger.verbose(addresses.governanceAddress.toString());
+  if (getAddress(await rollupContract.getOwner()) !== getAddress(addresses.governanceAddress.toString())) {
+    // TODO(md): add send transaction to the deployer such that we do not need to manage tx hashes here
+    const { txHash: transferOwnershipTxHash } = await deployer.sendTransaction({
+      to: rollupContract.address,
+      data: encodeFunctionData({
+        abi: RegistryArtifact.contractAbi,
+        functionName: 'transferOwnership',
+        args: [getAddress(addresses.governanceAddress.toString())],
+      }),
+    });
+    logger.verbose(
+      `Transferring the ownership of the rollup contract at ${rollupContract.address} to the Governance ${addresses.governanceAddress} in tx ${transferOwnershipTxHash}`,
+    );
+    txHashes.push(transferOwnershipTxHash);
+  }
+
   await deployer.waitForDeployments();
   await Promise.all(txHashes.map(txHash => extendedClient.waitForTransactionReceipt({ hash: txHash })));
   logger.verbose(`Rollup deployed`);
@@ -707,6 +710,8 @@ export const handoverToGovernance = async (
   deployer: L1Deployer,
   registryAddress: EthAddress,
   gseAddress: EthAddress,
+  coinIssuerAddress: EthAddress,
+  feeAssetAddress: EthAddress,
   governanceAddress: EthAddress,
   logger: Logger,
   acceleratedTestDeployments: boolean | undefined,
@@ -724,6 +729,18 @@ export const handoverToGovernance = async (
     client: extendedClient,
   });
 
+  const coinIssuerContract = getContract({
+    address: getAddress(coinIssuerAddress.toString()),
+    abi: CoinIssuerArtifact.contractAbi,
+    client: extendedClient,
+  });
+
+  const feeAsset = getContract({
+    address: getAddress(feeAssetAddress.toString()),
+    abi: FeeAssetArtifact.contractAbi,
+    client: extendedClient,
+  });
+
   const txHashes: Hex[] = [];
 
   // If the owner is not the Governance contract, transfer ownership to the Governance contract
@@ -763,6 +780,54 @@ export const handoverToGovernance = async (
     txHashes.push(transferOwnershipTxHash);
   }
 
+  if (acceleratedTestDeployments || (await feeAsset.read.owner()) !== coinIssuerAddress.toString()) {
+    const { txHash } = await deployer.sendTransaction(
+      {
+        to: feeAssetAddress.toString(),
+        data: encodeFunctionData({
+          abi: FeeAssetArtifact.contractAbi,
+          functionName: 'transferOwnership',
+          args: [coinIssuerAddress.toString()],
+        }),
+      },
+      { gasLimit: 500_000n },
+    );
+    logger.verbose(`Transfer ownership of fee asset to coin issuer ${coinIssuerAddress} in ${txHash}`);
+    txHashes.push(txHash);
+
+    const { txHash: acceptTokenOwnershipTxHash } = await deployer.sendTransaction(
+      {
+        to: coinIssuerAddress.toString(),
+        data: encodeFunctionData({
+          abi: CoinIssuerArtifact.contractAbi,
+          functionName: 'acceptTokenOwnership',
+        }),
+      },
+      { gasLimit: 500_000n },
+    );
+    logger.verbose(`Accept ownership of fee asset in ${acceptTokenOwnershipTxHash}`);
+    txHashes.push(acceptTokenOwnershipTxHash);
+  }
+
+  // If the owner is not the Governance contract, transfer ownership to the Governance contract
+  if (
+    acceleratedTestDeployments ||
+    (await coinIssuerContract.read.owner()) !== getAddress(governanceAddress.toString())
+  ) {
+    const { txHash: transferOwnershipTxHash } = await deployer.sendTransaction({
+      to: coinIssuerContract.address,
+      data: encodeFunctionData({
+        abi: CoinIssuerArtifact.contractAbi,
+        functionName: 'transferOwnership',
+        args: [getAddress(governanceAddress.toString())],
+      }),
+    });
+    logger.verbose(
+      `Transferring the ownership of the coin issuer contract at ${coinIssuerAddress} to the Governance ${governanceAddress} in tx ${transferOwnershipTxHash}`,
+    );
+    txHashes.push(transferOwnershipTxHash);
+  }
+
   // Wait for all actions to be mined
   await deployer.waitForDeployments();
   await Promise.all(txHashes.map(txHash => extendedClient.waitForTransactionReceipt({ hash: txHash })));
@@ -844,19 +909,51 @@ export const addMultipleValidators = async (
 
       logger.info(`Adding ${validators.length} validators to the rollup`);
 
-      await deployer.l1TxUtils.sendAndMonitorTransaction(
-        {
-          to: multiAdder.toString(),
-          data: encodeFunctionData({
-            abi: MultiAdderArtifact.contractAbi,
-            functionName: 'addValidators',
-            args: [validatorsTuples],
-          }),
-        },
-        {
-          gasLimit: 45_000_000n,
-        },
-      );
+      // Adding to the queue and flushing need to be done in two transactions
+      // if we are adding many validators.
+      if (validatorsTuples.length > 10) {
+        await deployer.l1TxUtils.sendAndMonitorTransaction(
+          {
+            to: multiAdder.toString(),
+            data: encodeFunctionData({
+              abi: MultiAdderArtifact.contractAbi,
+              functionName: 'addValidators',
+              args: [validatorsTuples, true],
+            }),
+          },
+          {
+            gasLimit: 40_000_000n,
+          },
+        );
+
+        await deployer.l1TxUtils.sendAndMonitorTransaction(
+          {
+            to: rollupAddress,
+            data: encodeFunctionData({
+              abi: RollupArtifact.contractAbi,
+              functionName: 'flushEntryQueue',
+              args: [],
+            }),
+          },
+          {
+            gasLimit: 40_000_000n,
+          },
+        );
+      } else {
+        await deployer.l1TxUtils.sendAndMonitorTransaction(
+          {
+            to: multiAdder.toString(),
+            data: encodeFunctionData({
+              abi: MultiAdderArtifact.contractAbi,
+              functionName: 'addValidators',
+              args: [validatorsTuples, false],
+            }),
+          },
+          {
+            gasLimit: 45_000_000n,
+          },
+        );
+      }
 
       const entryQueueLengthAfter = await rollup.getEntryQueueLength();
       const validatorCountAfter = await rollup.getActiveAttesterCount();
@@ -933,6 +1030,7 @@ export const deployL1Contracts = async (
   txUtilsConfig: L1TxUtilsConfig = getL1TxUtilsConfigEnvVars(),
   createVerificationJson: string | false = false,
 ): Promise<DeployL1ContractsReturnType> => {
+  logger.info(`Deploying L1 contracts with config: ${jsonStringify(args)}`);
   validateConfig(args);
 
   const l1Client = createExtendedL1Client(rpcUrls, account, chain);
@@ -995,6 +1093,7 @@ export const deployL1Contracts = async (
       gseAddress,
       rewardDistributorAddress,
       stakingAssetAddress,
+      governanceAddress,
     },
     logger,
   );
@@ -1008,6 +1107,8 @@ export const deployL1Contracts = async (
     deployer,
     registryAddress,
     gseAddress,
+    coinIssuerAddress,
+    feeAssetAddress,
     governanceAddress,
     logger,
     args.acceleratedTestDeployments,

package/src/test/eth_cheat_codes.ts

@@ -1,6 +1,6 @@
 import { toBigIntBE, toHex } from '@aztec/foundation/bigint-buffer';
 import { keccak256 } from '@aztec/foundation/crypto';
-import type { EthAddress } from '@aztec/foundation/eth-address';
+import { EthAddress } from '@aztec/foundation/eth-address';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 import { createLogger } from '@aztec/foundation/log';
 import type { TestDateProvider } from '@aztec/foundation/timer';
@@ -112,7 +112,7 @@ export class EthCheatCodes {
    * @param account - The account to set the balance for
    * @param balance - The balance to set
    */
-  public async setBalance(account: EthAddress, balance: bigint): Promise<void> {
+  public async setBalance(account: EthAddress | Hex, balance: bigint): Promise<void> {
     try {
       await this.rpcCall('anvil_setBalance', [account.toString(), toHex(balance)]);
     } catch (err) {
@@ -121,6 +121,11 @@ export class EthCheatCodes {
     this.logger.warn(`Set balance for ${account} to ${balance}`);
   }
 
+  public async getBalance(account: EthAddress | Hex): Promise<bigint> {
+    const res = await this.rpcCall('eth_getBalance', [account.toString(), 'latest']);
+    return BigInt(res);
+  }
+
   /**
    * Set the interval between successive blocks (block time). This does NOT enable interval mining.
    * @param interval - The interval to use between blocks
@@ -300,6 +305,11 @@ export class EthCheatCodes {
    */
   public async startImpersonating(who: EthAddress | Hex): Promise<void> {
     try {
+      // Since the `who` impersonated will sometimes be a contract without funds, we fund it if needed.
+      if ((await this.getBalance(who)) === 0n) {
+        await this.setBalance(who, 10n * 10n ** 18n);
+      }
+
       await this.rpcCall('hardhat_impersonateAccount', [who.toString()]);
     } catch (err) {
       throw new Error(`Error impersonating ${who}: ${err}`);

package/src/test/rollup_cheat_codes.ts

@@ -258,7 +258,11 @@ export class RollupCheatCodes {
    */
   public async setProvingCostPerMana(ethValue: bigint) {
     await this.asOwner(async (account, rollup) => {
-      const hash = await rollup.write.setProvingCostPerMana([ethValue], { account, chain: this.client.chain });
+      const hash = await rollup.write.setProvingCostPerMana([ethValue], {
+        account,
+        chain: this.client.chain,
+        gasLimit: 1000000n,
+      });
       await this.client.waitForTransactionReceipt({ hash });
       this.logger.warn(`Updated proving cost per mana to ${ethValue}`);
     });

package/src/test/tx_delayer.ts

@@ -18,7 +18,12 @@ import {
 
 import { type ViemClient, isExtendedClient } from '../types.js';
 
-export function waitUntilBlock<T extends Client>(client: T, blockNumber: number | bigint, logger?: Logger) {
+export function waitUntilBlock<T extends Client>(
+  client: T,
+  blockNumber: number | bigint,
+  logger?: Logger,
+  timeout?: number,
+) {
   const publicClient =
     'getBlockNumber' in client && typeof client.getBlockNumber === 'function'
       ? (client as unknown as PublicClient)
@@ -31,12 +36,17 @@ export function waitUntilBlock<T extends Client>(client: T, blockNumber: number
       return currentBlockNumber >= BigInt(blockNumber);
     },
     `Wait until L1 block ${blockNumber}`,
-    120,
+    timeout ?? 120,
     0.1,
   );
 }
 
-export function waitUntilL1Timestamp<T extends Client>(client: T, timestamp: number | bigint, logger?: Logger) {
+export function waitUntilL1Timestamp<T extends Client>(
+  client: T,
+  timestamp: number | bigint,
+  logger?: Logger,
+  timeout?: number,
+) {
   const publicClient =
     'getBlockNumber' in client && typeof client.getBlockNumber === 'function'
       ? (client as unknown as PublicClient)
@@ -56,7 +66,7 @@ export function waitUntilL1Timestamp<T extends Client>(client: T, timestamp: num
       return currentTs >= BigInt(timestamp);
     },
     `Wait until L1 timestamp ${timestamp}`,
-    120,
+    timeout ?? 120,
     0.1,
   );
 }