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

package/src/deploy_l1_contracts.ts

@@ -1,3 +1,4 @@
+import { L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/constants';
 import { SecretValue, getActiveNetworkName } from '@aztec/foundation/config';
 import { keccak256String } from '@aztec/foundation/crypto';
 import { EthAddress } from '@aztec/foundation/eth-address';
@@ -8,6 +9,7 @@ import { DateProvider } from '@aztec/foundation/timer';
 import type { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
 
 import type { Abi, Narrow } from 'abitype';
+import { mkdir, writeFile } from 'fs/promises';
 import {
   type Chain,
   type ContractConstructorArgs,
@@ -15,6 +17,7 @@ import {
   type Hex,
   type PrivateKeyAccount,
   concatHex,
+  encodeAbiParameters,
   encodeDeployData,
   encodeFunctionData,
   getAddress,
@@ -129,6 +132,19 @@ export interface ContractArtifacts<TAbi extends Abi | readonly unknown[] = Abi>
   libraries?: Libraries;
 }
 
+export type VerificationLibraryEntry = {
+  file: string;
+  contract: string;
+  address: string;
+};
+
+export type VerificationRecord = {
+  name: string;
+  address: string;
+  constructorArgsHex: Hex;
+  libraries: VerificationLibraryEntry[];
+};
+
 export interface DeployL1ContractsArgs extends Omit<L1ContractsConfig, keyof L1TxUtilsConfig> {
   /** The vk tree root. */
   vkTreeRoot: Fr;
@@ -247,36 +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;
@@ -292,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.
@@ -500,7 +497,12 @@ export const deployRollup = async (
   >,
   addresses: Pick<
     L1ContractAddresses,
-    'feeJuiceAddress' | 'registryAddress' | 'rewardDistributorAddress' | 'stakingAssetAddress' | 'gseAddress'
+    | 'feeJuiceAddress'
+    | 'registryAddress'
+    | 'rewardDistributorAddress'
+    | 'stakingAssetAddress'
+    | 'gseAddress'
+    | 'governanceAddress'
   >,
   logger: Logger,
 ) => {
@@ -678,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`);
@@ -690,6 +710,8 @@ export const handoverToGovernance = async (
   deployer: L1Deployer,
   registryAddress: EthAddress,
   gseAddress: EthAddress,
+  coinIssuerAddress: EthAddress,
+  feeAssetAddress: EthAddress,
   governanceAddress: EthAddress,
   logger: Logger,
   acceleratedTestDeployments: boolean | undefined,
@@ -707,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
@@ -746,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 })));
@@ -827,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();
@@ -914,7 +1028,9 @@ export const deployL1Contracts = async (
   logger: Logger,
   args: DeployL1ContractsArgs,
   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);
@@ -952,6 +1068,7 @@ export const deployL1Contracts = async (
     args.acceleratedTestDeployments,
     logger,
     txUtilsConfig,
+    !!createVerificationJson,
   );
 
   const {
@@ -964,6 +1081,7 @@ export const deployL1Contracts = async (
     governanceAddress,
     rewardDistributorAddress,
     zkPassportVerifierAddress,
+    coinIssuerAddress,
   } = await deploySharedContracts(l1Client, deployer, args, logger);
   const { rollup, slashFactoryAddress } = await deployRollup(
     l1Client,
@@ -975,6 +1093,7 @@ export const deployL1Contracts = async (
       gseAddress,
       rewardDistributorAddress,
       stakingAssetAddress,
+      governanceAddress,
     },
     logger,
   );
@@ -988,6 +1107,8 @@ export const deployL1Contracts = async (
     deployer,
     registryAddress,
     gseAddress,
+    coinIssuerAddress,
+    feeAssetAddress,
     governanceAddress,
     logger,
     args.acceleratedTestDeployments,
@@ -1000,6 +1121,147 @@ export const deployL1Contracts = async (
 
   logger.info(`Aztec L1 contracts initialized`, l1Contracts);
 
+  // Write verification data (constructor args + linked libraries) to file for later forge verify
+  if (createVerificationJson) {
+    try {
+      // Add Inbox / Outbox verification records (constructor args are created inside RollupCore)
+      const rollupAddr = l1Contracts.rollupAddress.toString();
+      const inboxAddr = l1Contracts.inboxAddress.toString();
+      const outboxAddr = l1Contracts.outboxAddress.toString();
+      const feeAsset = l1Contracts.feeJuiceAddress.toString();
+      const version = await rollup.getVersion();
+
+      const inboxCtor = encodeAbiParameters(
+        [{ type: 'address' }, { type: 'address' }, { type: 'uint256' }, { type: 'uint256' }],
+        [rollupAddr, feeAsset, version, BigInt(L1_TO_L2_MSG_SUBTREE_HEIGHT)],
+      );
+
+      const outboxCtor = encodeAbiParameters([{ type: 'address' }, { type: 'uint256' }], [rollupAddr, version]);
+
+      deployer.verificationRecords.push(
+        { name: 'Inbox', address: inboxAddr, constructorArgsHex: inboxCtor, libraries: [] },
+        { name: 'Outbox', address: outboxAddr, constructorArgsHex: outboxCtor, libraries: [] },
+      );
+
+      // Include Slasher and SlashingProposer (if deployed) in verification data
+      try {
+        const slasherAddrHex = await rollup.getSlasher();
+        const slasherAddr = EthAddress.fromString(slasherAddrHex);
+        if (!slasherAddr.isZero()) {
+          // Slasher constructor: (address _vetoer, address _governance)
+          const slasherCtor = encodeAbiParameters(
+            [{ type: 'address' }, { type: 'address' }],
+            [args.slashingVetoer.toString(), l1Client.account.address],
+          );
+          deployer.verificationRecords.push({
+            name: 'Slasher',
+            address: slasherAddr.toString(),
+            constructorArgsHex: slasherCtor,
+            libraries: [],
+          });
+
+          // Proposer address is stored in Slasher.PROPOSER()
+          const proposerAddr = (await rollup.getSlashingProposerAddress()).toString();
+
+          // Compute constructor args matching deployment path in RollupCore
+          const computedRoundSize = BigInt(args.slashingRoundSizeInEpochs * args.aztecEpochDuration);
+          const computedQuorum = BigInt(
+            args.slashingQuorum ?? (args.slashingRoundSizeInEpochs * args.aztecEpochDuration) / 2 + 1,
+          );
+          const lifetimeInRounds = BigInt(args.slashingLifetimeInRounds);
+          const executionDelayInRounds = BigInt(args.slashingExecutionDelayInRounds);
+
+          if (args.slasherFlavor === 'tally') {
+            const slashAmounts: readonly [bigint, bigint, bigint] = [
+              args.slashAmountSmall,
+              args.slashAmountMedium,
+              args.slashAmountLarge,
+            ];
+            const committeeSize = BigInt(args.aztecTargetCommitteeSize);
+            const epochDuration = BigInt(args.aztecEpochDuration);
+            const slashOffsetInRounds = BigInt(args.slashingOffsetInRounds);
+
+            const proposerCtor = encodeAbiParameters(
+              [
+                { type: 'address' },
+                { type: 'address' },
+                { type: 'uint256' },
+                { type: 'uint256' },
+                { type: 'uint256' },
+                { type: 'uint256' },
+                { type: 'uint256[3]' },
+                { type: 'uint256' },
+                { type: 'uint256' },
+                { type: 'uint256' },
+              ],
+              [
+                rollup.address,
+                slasherAddr.toString(),
+                computedQuorum,
+                computedRoundSize,
+                lifetimeInRounds,
+                executionDelayInRounds,
+                slashAmounts,
+                committeeSize,
+                epochDuration,
+                slashOffsetInRounds,
+              ],
+            );
+
+            deployer.verificationRecords.push({
+              name: 'TallySlashingProposer',
+              address: proposerAddr,
+              constructorArgsHex: proposerCtor,
+              libraries: [],
+            });
+          } else if (args.slasherFlavor === 'empire') {
+            const proposerCtor = encodeAbiParameters(
+              [
+                { type: 'address' },
+                { type: 'address' },
+                { type: 'uint256' },
+                { type: 'uint256' },
+                { type: 'uint256' },
+                { type: 'uint256' },
+              ],
+              [
+                rollup.address,
+                slasherAddr.toString(),
+                computedQuorum,
+                computedRoundSize,
+                lifetimeInRounds,
+                executionDelayInRounds,
+              ],
+            );
+
+            deployer.verificationRecords.push({
+              name: 'EmpireSlashingProposer',
+              address: proposerAddr,
+              constructorArgsHex: proposerCtor,
+              libraries: [],
+            });
+          }
+        }
+      } catch (e) {
+        logger.warn(`Failed to add Slasher/Proposer verification records: ${String(e)}`);
+      }
+      const date = new Date();
+      const formattedDate = date.toISOString().slice(2, 19).replace(/[-T:]/g, '');
+      // Ensure the verification output directory exists
+      await mkdir(createVerificationJson, { recursive: true });
+      const verificationOutputPath = `${createVerificationJson}/l1-verify-${chain.id}-${formattedDate.slice(0, 6)}-${formattedDate.slice(6)}.json`;
+      const verificationData = {
+        chainId: chain.id,
+        network: networkName,
+        records: deployer.verificationRecords,
+      };
+      await writeFile(verificationOutputPath, JSON.stringify(verificationData, null, 2));
+      logger.info(`Wrote L1 verification data to ${verificationOutputPath}`);
+    } catch (e) {
+      logger.warn(`Failed to write L1 verification data file: ${String(e)}`);
+    }
+  }
+
   if (isAnvilTestChain(chain.id)) {
     // @note  We make a time jump PAST the very first slot to not have to deal with the edge case of the first slot.
     //        The edge case being that the genesis block is already occupying slot 0, so we cannot have another block.
@@ -1032,6 +1294,7 @@ export const deployL1Contracts = async (
       feeAssetHandlerAddress,
       stakingAssetHandlerAddress,
       zkPassportVerifierAddress,
+      coinIssuerAddress,
     },
   };
 };
@@ -1040,6 +1303,7 @@ export class L1Deployer {
   private salt: Hex | undefined;
   private txHashes: Hex[] = [];
   public readonly l1TxUtils: L1TxUtils;
+  public readonly verificationRecords: VerificationRecord[] = [];
 
   constructor(
     public readonly client: ExtendedViemWalletClient,
@@ -1048,6 +1312,7 @@ export class L1Deployer {
     private acceleratedTestDeployments: boolean = false,
     private logger: Logger = createLogger('L1Deployer'),
     private txUtilsConfig?: L1TxUtilsConfig,
+    private createVerificationJson: boolean = false,
   ) {
     this.salt = maybeSalt ? padHex(numberToHex(maybeSalt), { size: 32 }) : undefined;
     this.l1TxUtils = createL1TxUtilsFromViemWallet(
@@ -1066,7 +1331,7 @@ export class L1Deployer {
   ): Promise<EthAddress> {
     this.logger.debug(`Deploying ${params.name} contract`, { args });
     try {
-      const { txHash, address } = await deployL1Contract(
+      const { txHash, address, deployedLibraries } = await deployL1Contract(
         this.client,
         params.contractAbi,
         params.contractBytecode,
@@ -1084,6 +1349,26 @@ export class L1Deployer {
         this.txHashes.push(txHash);
       }
       this.logger.debug(`Deployed ${params.name} at ${address}`, { args });
+
+      if (this.createVerificationJson) {
+        // Encode constructor args for verification
+        let constructorArgsHex: Hex = '0x';
+        try {
+          const abiItem: any = (params.contractAbi as any[]).find((x: any) => x && x.type === 'constructor');
+          const inputDefs: any[] = abiItem && Array.isArray(abiItem.inputs) ? abiItem.inputs : [];
+          constructorArgsHex =
+            inputDefs.length > 0 ? (encodeAbiParameters(inputDefs as any, (args ?? []) as any) as Hex) : ('0x' as Hex);
+        } catch {
+          constructorArgsHex = '0x' as Hex;
+        }
+
+        this.verificationRecords.push({
+          name: params.name,
+          address: address.toString(),
+          constructorArgsHex,
+          libraries: deployedLibraries ?? [],
+        });
+      }
       return address;
     } catch (error) {
       throw new Error(`Failed to deploy ${params.name}`, { cause: formatViemError(error) });
@@ -1142,9 +1427,10 @@ export async function deployL1Contract(
     gasLimit?: bigint;
     acceleratedTestDeployments?: boolean;
   } = {},
-): Promise<{ address: EthAddress; txHash: Hex | undefined }> {
+): Promise<{ address: EthAddress; txHash: Hex | undefined; deployedLibraries?: VerificationLibraryEntry[] }> {
   let txHash: Hex | undefined = undefined;
   let resultingAddress: Hex | null | undefined = undefined;
+  const deployedLibraries: VerificationLibraryEntry[] = [];
 
   const { salt: saltFromOpts, libraries, logger, gasLimit, acceleratedTestDeployments } = opts;
   let { l1TxUtils } = opts;
@@ -1179,10 +1465,29 @@ export async function deployL1Contract(
         optsWithoutLibraries,
       );
 
+      // Log deployed library name and address for easier verification/triage
+      logger?.verbose(`Linked library deployed`, { library: libraryName, address: address.toString(), txHash });
+
       if (txHash) {
         libraryTxs.push(txHash);
       }
 
+      // Try to find the source file for this library from linkReferences
+      let fileNameForLibrary: string | undefined = undefined;
+      for (const fileName in libraries.linkReferences) {
+        if (libraries.linkReferences[fileName] && libraries.linkReferences[fileName][libraryName]) {
+          fileNameForLibrary = fileName;
+          break;
+        }
+      }
+      if (fileNameForLibrary) {
+        deployedLibraries.push({
+          file: fileNameForLibrary,
+          contract: libraryName,
+          address: address.toString(),
+        });
+      }
+
       for (const linkRef in libraries.linkReferences) {
         for (const contractName in libraries.linkReferences[linkRef]) {
           // If the library name matches the one we just deployed, we replace it.
@@ -1264,7 +1569,7 @@ export async function deployL1Contract(
     }
   }
 
-  return { address: EthAddress.fromString(resultingAddress!), txHash };
+  return { address: EthAddress.fromString(resultingAddress!), txHash, deployedLibraries };
 }
 
 export function getExpectedAddress(

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,
   );
 }