@aztec/ethereum 0.66.0 → 0.67.1-devnet

package/src/deploy_l1_contracts.ts

@@ -1,7 +1,7 @@
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { type Fr } from '@aztec/foundation/fields';
-import { type DebugLogger } from '@aztec/foundation/log';
+import { type Logger } from '@aztec/foundation/log';
 import {
   CoinIssuerAbi,
   CoinIssuerBytecode,
@@ -284,7 +284,7 @@ export const deployL1Contracts = async (
   rpcUrl: string,
   account: HDAccount | PrivateKeyAccount,
   chain: Chain,
-  logger: DebugLogger,
+  logger: Logger,
   args: DeployL1ContractsArgs,
 ): Promise<DeployL1Contracts> => {
   // We are assuming that you are running this on a local anvil node which have 1s block times
@@ -304,10 +304,10 @@ export const deployL1Contracts = async (
     if (res.error) {
       throw new Error(`Error setting block interval: ${res.error.message}`);
     }
-    logger.info(`Set block interval to ${args.ethereumSlotDuration}`);
+    logger.warn(`Set block interval to ${args.ethereumSlotDuration}`);
   }
 
-  logger.info(`Deploying contracts from ${account.address.toString()}...`);
+  logger.verbose(`Deploying contracts from ${account.address.toString()}`);
 
   const walletClient = createWalletClient({ account, chain, transport: http(rpcUrl) });
   const publicClient = createPublicClient({ chain, transport: http(rpcUrl) });
@@ -315,21 +315,21 @@ export const deployL1Contracts = async (
   const govDeployer = new L1Deployer(walletClient, publicClient, args.salt, logger);
 
   const registryAddress = await govDeployer.deploy(l1Artifacts.registry, [account.address.toString()]);
-  logger.info(`Deployed Registry at ${registryAddress}`);
+  logger.verbose(`Deployed Registry at ${registryAddress}`);
 
   const feeAssetAddress = await govDeployer.deploy(l1Artifacts.feeAsset, [
     'FeeJuice',
     'FEE',
     account.address.toString(),
   ]);
-  logger.info(`Deployed Fee Juice at ${feeAssetAddress}`);
+  logger.verbose(`Deployed Fee Juice at ${feeAssetAddress}`);
 
   const stakingAssetAddress = await govDeployer.deploy(l1Artifacts.stakingAsset, [
     'Staking',
     'STK',
     account.address.toString(),
   ]);
-  logger.info(`Deployed Staking Asset at ${stakingAssetAddress}`);
+  logger.verbose(`Deployed Staking Asset at ${stakingAssetAddress}`);
 
   // @todo  #8084
   // @note These numbers are just chosen to make testing simple.
@@ -340,7 +340,7 @@ export const deployL1Contracts = async (
     quorumSize,
     roundSize,
   ]);
-  logger.info(`Deployed GovernanceProposer at ${governanceProposerAddress}`);
+  logger.verbose(`Deployed GovernanceProposer at ${governanceProposerAddress}`);
 
   // @note @LHerskind the assets are expected to be the same at some point, but for better
   // configurability they are different for now.
@@ -348,25 +348,25 @@ export const deployL1Contracts = async (
     feeAssetAddress.toString(),
     governanceProposerAddress.toString(),
   ]);
-  logger.info(`Deployed Governance at ${governanceAddress}`);
+  logger.verbose(`Deployed Governance at ${governanceAddress}`);
 
   const coinIssuerAddress = await govDeployer.deploy(l1Artifacts.coinIssuer, [
     feeAssetAddress.toString(),
     1n * 10n ** 18n, // @todo  #8084
     governanceAddress.toString(),
   ]);
-  logger.info(`Deployed CoinIssuer at ${coinIssuerAddress}`);
+  logger.verbose(`Deployed CoinIssuer at ${coinIssuerAddress}`);
 
   const rewardDistributorAddress = await govDeployer.deploy(l1Artifacts.rewardDistributor, [
     feeAssetAddress.toString(),
     registryAddress.toString(),
     governanceAddress.toString(),
   ]);
-  logger.info(`Deployed RewardDistributor at ${rewardDistributorAddress}`);
+  logger.verbose(`Deployed RewardDistributor at ${rewardDistributorAddress}`);
 
   logger.verbose(`Waiting for governance contracts to be deployed`);
   await govDeployer.waitForDeployments();
-  logger.info(`All governance contracts deployed`);
+  logger.verbose(`All governance contracts deployed`);
 
   const deployer = new L1Deployer(walletClient, publicClient, args.salt, logger);
 
@@ -375,7 +375,7 @@ export const deployL1Contracts = async (
     feeAssetAddress.toString(),
     args.l2FeeJuiceAddress.toString(),
   ]);
-  logger.info(`Deployed Fee Juice Portal at ${feeJuicePortalAddress}`);
+  logger.verbose(`Deployed Fee Juice Portal at ${feeJuicePortalAddress}`);
 
   const rollupConfigArgs = {
     aztecSlotDuration: args.aztecSlotDuration,
@@ -394,10 +394,10 @@ export const deployL1Contracts = async (
     rollupConfigArgs,
   ];
   const rollupAddress = await deployer.deploy(l1Artifacts.rollup, rollupArgs);
-  logger.info(`Deployed Rollup at ${rollupAddress}`, rollupConfigArgs);
+  logger.verbose(`Deployed Rollup at ${rollupAddress}`, rollupConfigArgs);
 
   await deployer.waitForDeployments();
-  logger.info(`All core contracts deployed`);
+  logger.verbose(`All core contracts have been deployed`);
 
   const feeJuicePortal = getContract({
     address: feeJuicePortalAddress.toString(),
@@ -428,13 +428,23 @@ export const deployL1Contracts = async (
 
   {
     const txHash = await feeAsset.write.setFreeForAll([true], {} as any);
-    logger.info(`Fee asset set to free for all in ${txHash}`);
+    logger.verbose(`Fee asset set to free for all in ${txHash}`);
     txHashes.push(txHash);
   }
 
-  if (args.initialValidators && args.initialValidators.length > 0) {
+  const attesters = (await rollup.read
+    .getAttesters([])
+    .then(attesters =>
+      (attesters as `0x${string}`[]).map(attester => EthAddress.fromString(attester.toString())),
+    )) as EthAddress[];
+
+  logger.debug(`Existing attesters`, attesters);
+
+  const newAttesters = (args.initialValidators ?? []).filter(v => !attesters.some(a => a.equals(v)));
+
+  if (newAttesters.length > 0) {
     // Mint tokens, approve them, use cheat code to initialise validator set without setting up the epoch.
-    const stakeNeeded = MINIMUM_STAKE * BigInt(args.initialValidators.length);
+    const stakeNeeded = MINIMUM_STAKE * BigInt(newAttesters.length);
     await Promise.all(
       [
         await stakingAsset.write.mint([walletClient.account.address, stakeNeeded], {} as any),
@@ -442,8 +452,10 @@ export const deployL1Contracts = async (
       ].map(txHash => publicClient.waitForTransactionReceipt({ hash: txHash })),
     );
 
+    logger.info(`Minted ${newAttesters.length} validators`);
+
     const initiateValidatorSetTxHash = await rollup.write.cheat__InitialiseValidatorSet([
-      args.initialValidators.map(v => ({
+      newAttesters.map(v => ({
         attester: v.toString(),
         proposer: v.toString(),
         withdrawer: v.toString(),
@@ -451,7 +463,7 @@ export const deployL1Contracts = async (
       })),
     ]);
     txHashes.push(initiateValidatorSetTxHash);
-    logger.info(`Initialized validator set (${args.initialValidators.join(', ')}) in tx ${initiateValidatorSetTxHash}`);
+    logger.info(`Initialized validator set (${newAttesters.join(', ')}) in tx ${initiateValidatorSetTxHash}`);
   }
 
   // @note  This value MUST match what is in `constants.nr`. It is currently specified here instead of just importing
@@ -464,7 +476,7 @@ export const deployL1Contracts = async (
   // @note  This is used to ensure we fully wait for the transaction when running against a real chain
   //        otherwise we execute subsequent transactions too soon
   await publicClient.waitForTransactionReceipt({ hash: mintTxHash });
-  logger.info(`Funding fee juice portal contract with fee juice in ${mintTxHash}`);
+  logger.verbose(`Funding fee juice portal contract with fee juice in ${mintTxHash}`);
 
   if (!(await feeJuicePortal.read.initialized([]))) {
     const initPortalTxHash = await feeJuicePortal.write.initialize([]);
@@ -474,7 +486,7 @@ export const deployL1Contracts = async (
     logger.verbose(`Fee juice portal is already initialized`);
   }
 
-  logger.info(
+  logger.verbose(
     `Initialized Fee Juice Portal at ${feeJuicePortalAddress} to bridge between L1 ${feeAssetAddress} to L2 ${args.l2FeeJuiceAddress}`,
   );
 
@@ -504,15 +516,15 @@ export const deployL1Contracts = async (
   // Set initial blocks as proven if requested
   if (args.assumeProvenThrough && args.assumeProvenThrough > 0) {
     await rollup.write.setAssumeProvenThroughBlockNumber([BigInt(args.assumeProvenThrough)], { account });
-    logger.info(`Set Rollup assumedProvenUntil to ${args.assumeProvenThrough}`);
+    logger.warn(`Rollup set to assumedProvenUntil to ${args.assumeProvenThrough}`);
   }
 
   // Inbox and Outbox are immutable and are deployed from Rollup's constructor so we just fetch them from the contract.
   const inboxAddress = EthAddress.fromString((await rollup.read.INBOX([])) as any);
-  logger.info(`Inbox available at ${inboxAddress}`);
+  logger.verbose(`Inbox available at ${inboxAddress}`);
 
   const outboxAddress = EthAddress.fromString((await rollup.read.OUTBOX([])) as any);
-  logger.info(`Outbox available at ${outboxAddress}`);
+  logger.verbose(`Outbox available at ${outboxAddress}`);
 
   // We need to call a function on the registry to set the various contract addresses.
   const registryContract = getContract({
@@ -521,6 +533,7 @@ export const deployL1Contracts = async (
     client: walletClient,
   });
   if (!(await registryContract.read.isRollupRegistered([getAddress(rollupAddress.toString())]))) {
+    logger.info(`Registry ${registryAddress} is not registered to rollup ${rollupAddress}`);
     const upgradeTxHash = await registryContract.write.upgrade([getAddress(rollupAddress.toString())], { account });
     logger.verbose(
       `Upgrading registry contract at ${registryAddress} to rollup ${rollupAddress} in tx ${upgradeTxHash}`,
@@ -562,6 +575,8 @@ export const deployL1Contracts = async (
     governanceAddress,
   };
 
+  logger.info(`Aztec L1 contracts initialized`, l1Contracts);
+
   return {
     walletClient,
     publicClient,
@@ -576,7 +591,7 @@ class L1Deployer {
     private walletClient: WalletClient<HttpTransport, Chain, Account>,
     private publicClient: PublicClient<HttpTransport, Chain>,
     maybeSalt: number | undefined,
-    private logger: DebugLogger,
+    private logger: Logger,
   ) {
     this.salt = maybeSalt ? padHex(numberToHex(maybeSalt), { size: 32 }) : undefined;
   }
@@ -666,7 +681,7 @@ export async function deployL1Contract(
   args: readonly unknown[] = [],
   maybeSalt?: Hex,
   libraries?: Libraries,
-  logger?: DebugLogger,
+  logger?: Logger,
 ): Promise<{ address: EthAddress; txHash: Hex | undefined }> {
   let txHash: Hex | undefined = undefined;
   let resultingAddress: Hex | null | undefined = undefined;

package/src/eth_cheat_codes.ts

@@ -1,9 +1,8 @@
 import { toBigIntBE, toHex } from '@aztec/foundation/bigint-buffer';
 import { keccak256 } from '@aztec/foundation/crypto';
 import { type EthAddress } from '@aztec/foundation/eth-address';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
 
-import fs from 'fs';
 import { type Hex } from 'viem';
 
 /**
@@ -18,7 +17,7 @@ export class EthCheatCodes {
     /**
      * The logger to use for the eth cheatcodes
      */
-    public logger = createDebugLogger('aztec:cheat_codes:eth'),
+    public logger = createLogger('ethereum:cheat_codes'),
   ) {}
 
   async rpcCall(method: string, params: any[]) {
@@ -77,11 +76,15 @@ export class EthCheatCodes {
    * @param numberOfBlocks - The number of blocks to mine
    */
   public async mine(numberOfBlocks = 1): Promise<void> {
+    await this.doMine(numberOfBlocks);
+    this.logger.verbose(`Mined ${numberOfBlocks} L1 blocks`);
+  }
+
+  private async doMine(numberOfBlocks = 1): Promise<void> {
     const res = await this.rpcCall('hardhat_mine', [numberOfBlocks]);
     if (res.error) {
       throw new Error(`Error mining: ${res.error.message}`);
     }
-    this.logger.verbose(`Mined ${numberOfBlocks} L1 blocks`);
   }
 
   /**
@@ -188,37 +191,10 @@ export class EthCheatCodes {
     if (res.error) {
       throw new Error(`Error warping: ${res.error.message}`);
     }
-    await this.mine();
+    await this.doMine();
     this.logger.verbose(`Warped L1 timestamp to ${timestamp}`);
   }
 
-  /**
-   * Dumps the current chain state to a file.
-   * @param fileName - The file name to dump state into
-   */
-  public async dumpChainState(fileName: string): Promise<void> {
-    const res = await this.rpcCall('hardhat_dumpState', []);
-    if (res.error) {
-      throw new Error(`Error dumping state: ${res.error.message}`);
-    }
-    const jsonContent = JSON.stringify(res.result);
-    fs.writeFileSync(`${fileName}.json`, jsonContent, 'utf8');
-    this.logger.verbose(`Dumped state to ${fileName}`);
-  }
-
-  /**
-   * Loads the chain state from a file.
-   * @param fileName - The file name to load state from
-   */
-  public async loadChainState(fileName: string): Promise<void> {
-    const data = JSON.parse(fs.readFileSync(`${fileName}.json`, 'utf8'));
-    const res = await this.rpcCall('hardhat_loadState', [data]);
-    if (res.error) {
-      throw new Error(`Error loading state: ${res.error.message}`);
-    }
-    this.logger.verbose(`Loaded state from ${fileName}`);
-  }
-
   /**
    * Load the value at a storage slot of a contract address on eth
    * @param contract - The contract address

package/src/l1_tx_utils.ts

@@ -1,10 +1,11 @@
+import { times } from '@aztec/foundation/collection';
 import {
   type ConfigMappingsType,
   bigintConfigHelper,
   getDefaultConfig,
   numberConfigHelper,
 } from '@aztec/foundation/config';
-import { type DebugLogger } from '@aztec/foundation/log';
+import { type Logger } from '@aztec/foundation/log';
 import { makeBackoff, retry } from '@aztec/foundation/retry';
 import { sleep } from '@aztec/foundation/sleep';
 
@@ -71,6 +72,11 @@ export interface L1TxUtilsConfig {
    * How long to wait for a tx to be mined before giving up
    */
   txTimeoutMs?: number;
+  /**
+   * How many attempts will be done to get a tx after it was sent?
+   * First attempt is done at 1s, second at 2s, third at 3s, etc.
+   */
+  txPropagationMaxQueryAttempts?: number;
 }
 
 export const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig> = {
@@ -119,6 +125,11 @@ export const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig> = {
     env: 'L1_TX_MONITOR_TX_TIMEOUT_MS',
     ...numberConfigHelper(300_000), // 5 mins
   },
+  txPropagationMaxQueryAttempts: {
+    description: 'How many attempts will be done to get a tx after it was sent',
+    env: 'L1_TX_PROPAGATION_MAX_QUERY_ATTEMPTS',
+    ...numberConfigHelper(3),
+  },
 };
 
 export const defaultL1TxUtilsConfig = getDefaultConfig<L1TxUtilsConfig>(l1TxUtilsConfigMappings);
@@ -129,6 +140,12 @@ export interface L1TxRequest {
   value?: bigint;
 }
 
+export interface L1BlobInputs {
+  blobs: Uint8Array[];
+  kzg: any;
+  maxFeePerBlobGas: bigint;
+}
+
 interface GasPrice {
   maxFeePerGas: bigint;
   maxPriorityFeePerGas: bigint;
@@ -140,7 +157,7 @@ export class L1TxUtils {
   constructor(
     private readonly publicClient: PublicClient,
     private readonly walletClient: WalletClient<HttpTransport, Chain, Account>,
-    private readonly logger?: DebugLogger,
+    private readonly logger?: Logger,
     config?: Partial<L1TxUtilsConfig>,
   ) {
     this.config = {
@@ -158,6 +175,7 @@ export class L1TxUtils {
   public async sendTransaction(
     request: L1TxRequest,
     _gasConfig?: Partial<L1TxUtilsConfig> & { fixedGas?: bigint },
+    _blobInputs?: L1BlobInputs,
   ): Promise<{ txHash: Hex; gasLimit: bigint; gasPrice: GasPrice }> {
     const gasConfig = { ...this.config, ..._gasConfig };
     const account = this.walletClient.account;
@@ -171,16 +189,20 @@ export class L1TxUtils {
 
     const gasPrice = await this.getGasPrice(gasConfig);
 
+    const blobInputs = _blobInputs || {};
     const txHash = await this.walletClient.sendTransaction({
       ...request,
+      ...blobInputs,
       gas: gasLimit,
       maxFeePerGas: gasPrice.maxFeePerGas,
       maxPriorityFeePerGas: gasPrice.maxPriorityFeePerGas,
     });
 
-    this.logger?.verbose(
-      `Sent L1 transaction ${txHash} with gas limit ${gasLimit} and price ${formatGwei(gasPrice.maxFeePerGas)} gwei`,
-    );
+    this.logger?.verbose(`Sent L1 transaction ${txHash}`, {
+      gasLimit,
+      maxFeePerGas: formatGwei(gasPrice.maxFeePerGas),
+      maxPriorityFeePerGas: formatGwei(gasPrice.maxPriorityFeePerGas),
+    });
 
     return { txHash, gasLimit, gasPrice };
   }
@@ -197,15 +219,19 @@ export class L1TxUtils {
     initialTxHash: Hex,
     params: { gasLimit: bigint },
     _gasConfig?: Partial<L1TxUtilsConfig>,
+    _blobInputs?: L1BlobInputs,
   ): Promise<TransactionReceipt> {
     const gasConfig = { ...this.config, ..._gasConfig };
     const account = this.walletClient.account;
+    const blobInputs = _blobInputs || {};
+    const makeGetTransactionBackoff = () =>
+      makeBackoff(times(gasConfig.txPropagationMaxQueryAttempts ?? 3, i => i + 1));
 
     // Retry a few times, in case the tx is not yet propagated.
     const tx = await retry<GetTransactionReturnType>(
       () => this.publicClient.getTransaction({ hash: initialTxHash }),
       `Getting L1 transaction ${initialTxHash}`,
-      makeBackoff([1, 2, 3]),
+      makeGetTransactionBackoff(),
       this.logger,
       true,
     );
@@ -230,9 +256,9 @@ export class L1TxUtils {
             try {
               const receipt = await this.publicClient.getTransactionReceipt({ hash });
               if (receipt) {
-                this.logger?.debug(`L1 Transaction ${hash} confirmed`);
+                this.logger?.debug(`L1 transaction ${hash} mined`);
                 if (receipt.status === 'reverted') {
-                  this.logger?.error(`L1 Transaction ${hash} reverted`);
+                  this.logger?.error(`L1 transaction ${hash} reverted`);
                 }
                 return receipt;
               }
@@ -248,14 +274,14 @@ export class L1TxUtils {
         const tx = await retry<GetTransactionReturnType>(
           () => this.publicClient.getTransaction({ hash: currentTxHash }),
           `Getting L1 transaction ${currentTxHash}`,
-          makeBackoff([1, 2, 3]),
+          makeGetTransactionBackoff(),
           this.logger,
           true,
         );
         const timePassed = Date.now() - lastAttemptSent;
 
         if (tx && timePassed < gasConfig.stallTimeMs!) {
-          this.logger?.debug(`L1 Transaction ${currentTxHash} pending. Time passed: ${timePassed}ms`);
+          this.logger?.debug(`L1 transaction ${currentTxHash} pending. Time passed: ${timePassed}ms.`);
 
           // Check timeout before continuing
           if (gasConfig.txTimeoutMs) {
@@ -280,12 +306,13 @@ export class L1TxUtils {
           );
 
           this.logger?.debug(
-            `L1 Transaction ${currentTxHash} appears stuck. Attempting speed-up ${attempts}/${gasConfig.maxAttempts} ` +
+            `L1 transaction ${currentTxHash} appears stuck. Attempting speed-up ${attempts}/${gasConfig.maxAttempts} ` +
               `with new priority fee ${formatGwei(newGasPrice.maxPriorityFeePerGas)} gwei`,
           );
 
           currentTxHash = await this.walletClient.sendTransaction({
             ...request,
+            ...blobInputs,
             nonce,
             gas: params.gasLimit,
             maxFeePerGas: newGasPrice.maxFeePerGas,
@@ -308,7 +335,7 @@ export class L1TxUtils {
         txTimedOut = Date.now() - initialTxTime > gasConfig.txTimeoutMs!;
       }
     }
-    throw new Error(`L1 Transaction ${currentTxHash} timed out`);
+    throw new Error(`L1 transaction ${currentTxHash} timed out`);
   }
 
   /**
@@ -320,9 +347,10 @@ export class L1TxUtils {
   public async sendAndMonitorTransaction(
     request: L1TxRequest,
     gasConfig?: Partial<L1TxUtilsConfig> & { fixedGas?: bigint },
+    blobInputs?: L1BlobInputs,
   ): Promise<TransactionReceipt> {
-    const { txHash, gasLimit } = await this.sendTransaction(request, gasConfig);
-    return this.monitorTransaction(request, txHash, { gasLimit }, gasConfig);
+    const { txHash, gasLimit } = await this.sendTransaction(request, gasConfig, blobInputs);
+    return this.monitorTransaction(request, txHash, { gasLimit }, gasConfig, blobInputs);
   }
 
   /**
@@ -377,10 +405,12 @@ export class L1TxUtils {
     // Ensure priority fee doesn't exceed max fee
     const maxPriorityFeePerGas = priorityFee > maxFeePerGas ? maxFeePerGas : priorityFee;
 
-    this.logger?.debug(
-      `Gas price calculation (attempt ${attempt}): baseFee=${formatGwei(baseFee)}, ` +
-        `maxPriorityFee=${formatGwei(maxPriorityFeePerGas)}, maxFee=${formatGwei(maxFeePerGas)}`,
-    );
+    this.logger?.debug(`Computed gas price`, {
+      attempt,
+      baseFee: formatGwei(baseFee),
+      maxFeePerGas: formatGwei(maxFeePerGas),
+      maxPriorityFeePerGas: formatGwei(maxPriorityFeePerGas),
+    });
 
     return { maxFeePerGas, maxPriorityFeePerGas };
   }
@@ -388,9 +418,23 @@ export class L1TxUtils {
   /**
    * Estimates gas and adds buffer
    */
-  public async estimateGas(account: Account, request: L1TxRequest, _gasConfig?: L1TxUtilsConfig): Promise<bigint> {
+  public async estimateGas(
+    account: Account,
+    request: L1TxRequest,
+    _gasConfig?: L1TxUtilsConfig,
+    _blobInputs?: L1BlobInputs,
+  ): Promise<bigint> {
     const gasConfig = { ...this.config, ..._gasConfig };
-    const initialEstimate = await this.publicClient.estimateGas({ account, ...request });
+    let initialEstimate = 0n;
+    // Viem does not allow blobs to be sent via public client's estimate gas, so any estimation will fail.
+    // Strangely, the only way to get gas and send blobs is prepareTransactionRequest().
+    // See: https://github.com/wevm/viem/issues/2075
+    if (_blobInputs) {
+      initialEstimate = (await this.walletClient.prepareTransactionRequest({ account, ...request, ..._blobInputs }))
+        .gas;
+    } else {
+      initialEstimate = await this.publicClient.estimateGas({ account, ...request });
+    }
 
     // Add buffer based on either fixed amount or percentage
     const withBuffer = initialEstimate + (initialEstimate * (gasConfig.gasLimitBufferPercentage ?? 0n)) / 100n;

package/src/test/eth_cheat_codes_with_state.ts

@@ -0,0 +1,36 @@
+import fs from 'fs';
+
+import { EthCheatCodes } from '../eth_cheat_codes.js';
+
+/**
+ * A class that provides utility functions for interacting with ethereum (L1) dumping/loading state to/from a file.
+ * It is separated to avoid importing fs in the main EthCheatCodes class, which might be used in the browser.
+ */
+export class EthCheatCodesWithState extends EthCheatCodes {
+  /**
+   * Dumps the current chain state to a file.
+   * @param fileName - The file name to dump state into
+   */
+  public async dumpChainState(fileName: string): Promise<void> {
+    const res = await this.rpcCall('hardhat_dumpState', []);
+    if (res.error) {
+      throw new Error(`Error dumping state: ${res.error.message}`);
+    }
+    const jsonContent = JSON.stringify(res.result);
+    fs.writeFileSync(`${fileName}.json`, jsonContent, 'utf8');
+    this.logger.verbose(`Dumped state to ${fileName}`);
+  }
+
+  /**
+   * Loads the chain state from a file.
+   * @param fileName - The file name to load state from
+   */
+  public async loadChainState(fileName: string): Promise<void> {
+    const data = JSON.parse(fs.readFileSync(`${fileName}.json`, 'utf8'));
+    const res = await this.rpcCall('hardhat_loadState', [data]);
+    if (res.error) {
+      throw new Error(`Error loading state: ${res.error.message}`);
+    }
+    this.logger.verbose(`Loaded state from ${fileName}`);
+  }
+}

package/src/test/index.ts

@@ -1,2 +1,3 @@
 export * from './start_anvil.js';
 export * from './tx_delayer.js';
+export * from './eth_cheat_codes_with_state.js';

package/src/test/tx_delayer.ts

@@ -1,4 +1,5 @@
-import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
+import { omit } from '@aztec/foundation/collection';
+import { type Logger, createLogger } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
 
 import { inspect } from 'util';
@@ -8,11 +9,12 @@ import {
   type PublicClient,
   type WalletClient,
   keccak256,
+  parseTransaction,
   publicActions,
   walletActions,
 } from 'viem';
 
-export function waitUntilBlock<T extends Client>(client: T, blockNumber: number | bigint, logger?: DebugLogger) {
+export function waitUntilBlock<T extends Client>(client: T, blockNumber: number | bigint, logger?: Logger) {
   const publicClient =
     'getBlockNumber' in client && typeof client.getBlockNumber === 'function'
       ? (client as unknown as PublicClient)
@@ -30,7 +32,7 @@ export function waitUntilBlock<T extends Client>(client: T, blockNumber: number
   );
 }
 
-export function waitUntilL1Timestamp<T extends Client>(client: T, timestamp: number | bigint, logger?: DebugLogger) {
+export function waitUntilL1Timestamp<T extends Client>(client: T, timestamp: number | bigint, logger?: Logger) {
   const publicClient =
     'getBlockNumber' in client && typeof client.getBlockNumber === 'function'
       ? (client as unknown as PublicClient)
@@ -89,12 +91,13 @@ class DelayerImpl implements Delayer {
 /**
  * Returns a new client (without modifying the one passed in) with an injected tx delayer.
  * The delayer can be used to hold off the next tx to be sent until a given block number.
+ * TODO(#10824): This doesn't play along well with blob txs for some reason.
  */
 export function withDelayer<T extends WalletClient>(
   client: T,
   opts: { ethereumSlotDuration: bigint | number },
 ): { client: T; delayer: Delayer } {
-  const logger = createDebugLogger('aztec:ethereum:tx_delayer');
+  const logger = createLogger('ethereum:tx_delayer');
   const delayer = new DelayerImpl(opts);
   const extended = client
     // Tweak sendRawTransaction so it uses the delay defined in the delayer.
@@ -116,16 +119,25 @@ export function withDelayer<T extends WalletClient>(
           // Compute the tx hash manually so we emulate sendRawTransaction response
           const { serializedTransaction } = args[0];
           const txHash = keccak256(serializedTransaction);
-          logger.info(`Delaying tx ${txHash} until ${inspect(waitUntil)}`);
+          logger.info(`Delaying tx ${txHash} until ${inspect(waitUntil)}`, {
+            argsLen: args.length,
+            ...omit(parseTransaction(serializedTransaction), 'data', 'sidecars'),
+          });
 
           // Do not await here so we can return the tx hash immediately as if it had been sent on the spot.
           // Instead, delay it so it lands on the desired block number or timestamp, assuming anvil will
           // mine it immediately.
           void wait
             .then(async () => {
-              const txHash = await client.sendRawTransaction(...args);
-              logger.info(`Sent previously delayed tx ${txHash} to land on ${inspect(waitUntil)}`);
-              delayer.txs.push(txHash);
+              const clientTxHash = await client.sendRawTransaction(...args);
+              if (clientTxHash !== txHash) {
+                logger.error(`Tx hash returned by the client does not match computed one`, {
+                  clientTxHash,
+                  computedTxHash: txHash,
+                });
+              }
+              logger.info(`Sent previously delayed tx ${clientTxHash} to land on ${inspect(waitUntil)}`);
+              delayer.txs.push(clientTxHash);
             })
             .catch(err => logger.error(`Error sending tx after delay`, err));
 

package/src/utils.ts

@@ -1,5 +1,5 @@
 import { type Fr } from '@aztec/foundation/fields';
-import { type DebugLogger } from '@aztec/foundation/log';
+import { type Logger } from '@aztec/foundation/log';
 
 import {
   type Abi,
@@ -27,7 +27,7 @@ export function extractEvent<
   abi: TAbi,
   eventName: TEventName,
   filter?: (log: TEventType) => boolean,
-  logger?: DebugLogger,
+  logger?: Logger,
 ): TEventType {
   const event = tryExtractEvent(logs, address, abi, eventName, filter, logger);
   if (!event) {
@@ -46,7 +46,7 @@ function tryExtractEvent<
   abi: TAbi,
   eventName: TEventName,
   filter?: (log: TEventType) => boolean,
-  logger?: DebugLogger,
+  logger?: Logger,
 ): TEventType | undefined {
   for (const log of logs) {
     if (log.address.toLowerCase() === address.toLowerCase()) {