@aztec/end-to-end 0.85.0 → 0.86.0-nightly.20250426

package/src/e2e_p2p/p2p_network.ts

@@ -2,8 +2,13 @@ import { getSchnorrWalletWithSecretKey } from '@aztec/accounts/schnorr';
 import type { InitialAccountData } from '@aztec/accounts/testing';
 import type { AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
 import type { AccountWalletWithSecretKey } from '@aztec/aztec.js';
-import { RollupContract, getExpectedAddress, getL1ContractsConfigEnvVars } from '@aztec/ethereum';
-import { L1TxUtilsWithBlobs } from '@aztec/ethereum/l1-tx-utils-with-blobs';
+import {
+  type ExtendedViemWalletClient,
+  L1TxUtils,
+  RollupContract,
+  getExpectedAddress,
+  getL1ContractsConfigEnvVars,
+} from '@aztec/ethereum';
 import { ChainMonitor, EthCheatCodesWithState } from '@aztec/ethereum/test';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { ForwarderAbi, ForwarderBytecode, RollupAbi, TestERC20Abi } from '@aztec/l1-artifacts';
@@ -66,10 +71,6 @@ export class P2PNetworkTest {
 
   public bootstrapNode?: BootstrapNode;
 
-  private cleanupInterval: NodeJS.Timeout | undefined = undefined;
-
-  private gasUtils: L1TxUtilsWithBlobs | undefined = undefined;
-
   constructor(
     testName: string,
     public bootstrapNodeEnr: string,
@@ -147,32 +148,6 @@ export class P2PNetworkTest {
     return this.deployedAccounts[0];
   }
 
-  /**
-   * Start a loop to sync the mock system time with the L1 block time
-   */
-  public startSyncMockSystemTimeInterval() {
-    this.cleanupInterval = setInterval(() => {
-      void this.syncMockSystemTime().catch(err => this.logger.error('Error syncing mock system time', err));
-    }, l1ContractsConfig.aztecSlotDuration * 1000);
-  }
-
-  /**
-   * When using fake timers, we need to keep the system and anvil clocks in sync.
-   */
-  public async syncMockSystemTime() {
-    this.logger.info('Syncing mock system time');
-    const { dateProvider, deployL1ContractsValues } = this.ctx!;
-    // Send a tx and only update the time after the tx is mined, as eth time is not continuous
-    const { receipt } = await this.gasUtils!.sendAndMonitorTransaction({
-      to: this.baseAccount.address,
-      data: '0x',
-      value: 1n,
-    });
-    const timestamp = await deployL1ContractsValues.publicClient.getBlock({ blockNumber: receipt.blockNumber });
-    this.logger.info(`Timestamp: ${timestamp.timestamp}`);
-    dateProvider.setTime(Number(timestamp.timestamp) * 1000);
-  }
-
   async addBootstrapNode() {
     await this.snapshotManager.snapshot('add-bootstrap-node', async ({ aztecNodeConfig }) => {
       const telemetry = getEndToEndTestTelemetryClient(this.metricsPort);
@@ -215,14 +190,13 @@ export class P2PNetworkTest {
 
   async applyBaseSnapshots() {
     await this.addBootstrapNode();
-
     await this.snapshotManager.snapshot(
       'add-validators',
       async ({ deployL1ContractsValues, aztecNodeConfig, dateProvider }) => {
         const rollup = getContract({
           address: deployL1ContractsValues.l1ContractAddresses.rollupAddress.toString(),
           abi: RollupAbi,
-          client: deployL1ContractsValues.walletClient,
+          client: deployL1ContractsValues.l1Client,
         });
 
         this.logger.verbose(`Adding ${this.numberOfNodes} validators`);
@@ -230,26 +204,23 @@ export class P2PNetworkTest {
         const stakingAsset = getContract({
           address: deployL1ContractsValues.l1ContractAddresses.stakingAssetAddress.toString(),
           abi: TestERC20Abi,
-          client: deployL1ContractsValues.walletClient,
+          client: deployL1ContractsValues.l1Client,
         });
 
         const stakeNeeded = l1ContractsConfig.minimumStake * BigInt(this.numberOfNodes);
         await Promise.all(
           [
-            await stakingAsset.write.mint(
-              [deployL1ContractsValues.walletClient.account.address, stakeNeeded],
-              {} as any,
-            ),
+            await stakingAsset.write.mint([deployL1ContractsValues.l1Client.account.address, stakeNeeded], {} as any),
             await stakingAsset.write.approve(
               [deployL1ContractsValues.l1ContractAddresses.rollupAddress.toString(), stakeNeeded],
               {} as any,
             ),
-          ].map(txHash => deployL1ContractsValues.publicClient.waitForTransactionReceipt({ hash: txHash })),
+          ].map(txHash => deployL1ContractsValues.l1Client.waitForTransactionReceipt({ hash: txHash })),
         );
 
         const { validators } = this.getValidators();
         this.validators = validators;
-        await deployL1ContractsValues.publicClient.waitForTransactionReceipt({
+        await deployL1ContractsValues.l1Client.waitForTransactionReceipt({
           hash: await rollup.write.cheat__InitialiseValidatorSet([this.validators]),
         });
 
@@ -263,13 +234,7 @@ export class P2PNetworkTest {
         }
 
         // Send and await a tx to make sure we mine a block for the warp to correctly progress.
-        await deployL1ContractsValues.publicClient.waitForTransactionReceipt({
-          hash: await deployL1ContractsValues.walletClient.sendTransaction({
-            to: this.baseAccount.address,
-            value: 1n,
-            account: this.baseAccount,
-          }),
-        });
+        await this._sendDummyTx(deployL1ContractsValues.l1Client);
 
         // Set the system time in the node, only after we have warped the time and waited for a block
         // Time is only set in the NEXT block
@@ -315,14 +280,8 @@ export class P2PNetworkTest {
       'remove-inital-validator',
       async ({ deployL1ContractsValues, aztecNode, dateProvider }) => {
         // Send and await a tx to make sure we mine a block for the warp to correctly progress.
-        const receipt = await deployL1ContractsValues.publicClient.waitForTransactionReceipt({
-          hash: await deployL1ContractsValues.walletClient.sendTransaction({
-            to: this.baseAccount.address,
-            value: 1n,
-            account: this.baseAccount,
-          }),
-        });
-        const block = await deployL1ContractsValues.publicClient.getBlock({
+        const { receipt } = await this._sendDummyTx(deployL1ContractsValues.l1Client);
+        const block = await deployL1ContractsValues.l1Client.getBlock({
           blockNumber: receipt.blockNumber,
         });
         dateProvider.setTime(Number(block.timestamp) * 1000);
@@ -332,6 +291,18 @@ export class P2PNetworkTest {
     );
   }
 
+  async sendDummyTx() {
+    return await this._sendDummyTx(this.ctx.deployL1ContractsValues.l1Client);
+  }
+
+  private async _sendDummyTx(l1Client: ExtendedViemWalletClient) {
+    const l1TxUtils = new L1TxUtils(l1Client);
+    return await l1TxUtils.sendAndMonitorTransaction({
+      to: l1Client.account!.address,
+      value: 1n,
+    });
+  }
+
   async setup() {
     this.ctx = await this.snapshotManager.setup();
 
@@ -341,22 +312,8 @@ export class P2PNetworkTest {
     const { prefilledPublicData } = await getGenesisValues(initialFundedAccounts);
     this.prefilledPublicData = prefilledPublicData;
 
-    this.startSyncMockSystemTimeInterval();
-
-    this.gasUtils = new L1TxUtilsWithBlobs(
-      this.ctx.deployL1ContractsValues.publicClient,
-      this.ctx.deployL1ContractsValues.walletClient,
-      this.logger,
-      {
-        gasLimitBufferPercentage: 20,
-        maxGwei: 500n,
-        maxAttempts: 3,
-        checkIntervalMs: 100,
-        stallTimeMs: 1000,
-      },
-    );
-
     this.monitor = new ChainMonitor(RollupContract.getFromL1ContractsValues(this.ctx.deployL1ContractsValues)).start();
+    this.monitor.on('l1-block', ({ timestamp }) => this.ctx.dateProvider.setTime(Number(timestamp) * 1000));
   }
 
   async stopNodes(nodes: AztecNodeService[]) {
@@ -376,8 +333,5 @@ export class P2PNetworkTest {
     this.monitor.stop();
     await this.bootstrapNode?.stop();
     await this.snapshotManager.teardown();
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
-    }
   }
 }

package/src/e2e_prover/e2e_prover_test.ts

@@ -282,7 +282,7 @@ export class FullProverTest {
     this.logger.verbose('Starting prover node');
     const proverConfig: ProverNodeConfig = {
       ...this.context.aztecNodeConfig,
-      proverCoordinationNodeUrl: undefined,
+      proverCoordinationNodeUrls: [],
       dataDirectory: undefined,
       proverId: this.proverAddress.toField(),
       realProofs: this.realProofs,
@@ -291,9 +291,10 @@ export class FullProverTest {
       proverNodeMaxPendingJobs: 100,
       proverNodeMaxParallelBlocksPerEpoch: 32,
       proverNodePollingIntervalMs: 100,
-      txGatheringTimeoutMs: 60000,
       txGatheringIntervalMs: 1000,
-      txGatheringMaxParallelRequests: 100,
+      txGatheringBatchSize: 10,
+      txGatheringMaxParallelRequestsPerNode: 100,
+      proverNodeFailedEpochStore: undefined,
     };
     const sponsoredFPCAddress = await getSponsoredFPCAddress();
     const { prefilledPublicData } = await getGenesisValues(
@@ -308,7 +309,7 @@ export class FullProverTest {
       },
       { prefilledPublicData },
     );
-    this.proverNode.start();
+    await this.proverNode.start();
 
     this.logger.warn(`Proofs are now enabled`);
     return this;
@@ -316,10 +317,10 @@ export class FullProverTest {
 
   private async mintL1ERC20(recipient: Hex, amount: bigint) {
     const erc20Address = this.context.deployL1ContractsValues.l1ContractAddresses.feeJuiceAddress;
-    const client = this.context.deployL1ContractsValues.walletClient;
+    const client = this.context.deployL1ContractsValues.l1Client;
     const erc20 = getContract({ abi: TestERC20Abi, address: erc20Address.toString(), client });
     const hash = await erc20.write.mint([recipient, amount]);
-    await this.context.deployL1ContractsValues.publicClient.waitForTransactionReceipt({ hash });
+    await this.context.deployL1ContractsValues.l1Client.waitForTransactionReceipt({ hash });
   }
 
   snapshot = <T>(
@@ -399,19 +400,14 @@ export class FullProverTest {
       throw new Error('No verifier');
     }
 
-    const { walletClient, publicClient, l1ContractAddresses } = this.context.deployL1ContractsValues;
+    const { l1Client, l1ContractAddresses } = this.context.deployL1ContractsValues;
     const rollup = getContract({
       abi: RollupAbi,
       address: l1ContractAddresses.rollupAddress.toString(),
-      client: walletClient,
+      client: l1Client,
     });
 
-    const { address: verifierAddress } = await deployL1Contract(
-      walletClient,
-      publicClient,
-      HonkVerifierAbi,
-      HonkVerifierBytecode,
-    );
+    const { address: verifierAddress } = await deployL1Contract(l1Client, HonkVerifierAbi, HonkVerifierBytecode);
     this.logger.info(`Deployed honk verifier at ${verifierAddress}`);
 
     await rollup.write.setEpochVerifier([verifierAddress.toString()]);

package/src/fixtures/l1_to_l2_messaging.ts

@@ -1,9 +1,4 @@
-import {
-  type L1ContractAddresses,
-  RollupContract,
-  type ViemPublicClient,
-  type ViemWalletClient,
-} from '@aztec/ethereum';
+import { type ExtendedViemWalletClient, type L1ContractAddresses, RollupContract } from '@aztec/ethereum';
 import { Fr } from '@aztec/foundation/fields';
 import { InboxAbi } from '@aztec/l1-artifacts';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
@@ -14,23 +9,19 @@ import { decodeEventLog, getContract } from 'viem';
 export async function sendL1ToL2Message(
   message: { recipient: AztecAddress; content: Fr; secretHash: Fr },
   ctx: {
-    walletClient: ViemWalletClient;
-    publicClient: ViemPublicClient;
+    l1Client: ExtendedViemWalletClient;
     l1ContractAddresses: Pick<L1ContractAddresses, 'inboxAddress' | 'rollupAddress'>;
   },
 ) {
   const inbox = getContract({
     address: ctx.l1ContractAddresses.inboxAddress.toString(),
     abi: InboxAbi,
-    client: ctx.walletClient,
+    client: ctx.l1Client,
   });
 
   const { recipient, content, secretHash } = message;
 
-  const version = await new RollupContract(
-    ctx.publicClient,
-    ctx.l1ContractAddresses.rollupAddress.toString(),
-  ).getVersion();
+  const version = await new RollupContract(ctx.l1Client, ctx.l1ContractAddresses.rollupAddress.toString()).getVersion();
 
   // We inject the message to Inbox
   const txHash = await inbox.write.sendL2Message([
@@ -40,7 +31,7 @@ export async function sendL1ToL2Message(
   ]);
 
   // We check that the message was correctly injected by checking the emitted event
-  const txReceipt = await ctx.publicClient.waitForTransactionReceipt({ hash: txHash });
+  const txReceipt = await ctx.l1Client.waitForTransactionReceipt({ hash: txHash });
 
   // Exactly 1 event should be emitted in the transaction
   expect(txReceipt.logs.length).toBe(1);

package/src/fixtures/setup_l1_contracts.ts

@@ -12,8 +12,7 @@ export const setupL1Contracts = async (
   l1RpcUrl: string,
   account: HDAccount | PrivateKeyAccount,
   logger: Logger,
-  args: Pick<DeployL1ContractsArgs, 'genesisArchiveRoot' | 'genesisBlockHash' | 'initialValidators'> &
-    L1ContractsConfig,
+  args: Pick<DeployL1ContractsArgs, 'genesisArchiveRoot' | 'initialValidators'> & L1ContractsConfig,
 ) => {
   const l1Data = await deployL1Contracts([l1RpcUrl], account, foundry, logger, {
     vkTreeRoot: getVKTreeRoot(),

package/src/fixtures/snapshot_manager.ts

@@ -20,7 +20,7 @@ import { type BlobSinkServer, createBlobSinkServer } from '@aztec/blob-sink/serv
 import {
   type DeployL1ContractsArgs,
   type DeployL1ContractsReturnType,
-  createL1Clients,
+  createExtendedL1Client,
   getL1ContractsConfigEnvVars,
   l1Artifacts,
 } from '@aztec/ethereum';
@@ -348,7 +348,7 @@ async function setupFromFresh(
 
   const initialFundedAccounts = await generateSchnorrAccounts(numberOfInitialFundedAccounts);
   const sponsoredFPCAddress = await getSponsoredFPCAddress();
-  const { genesisArchiveRoot, genesisBlockHash, prefilledPublicData, fundingNeeded } = await getGenesisValues(
+  const { genesisArchiveRoot, prefilledPublicData, fundingNeeded } = await getGenesisValues(
     initialFundedAccounts.map(a => a.address).concat(sponsoredFPCAddress),
     opts.initialAccountFeeJuice,
   );
@@ -356,7 +356,6 @@ async function setupFromFresh(
   const deployL1ContractsValues = await setupL1Contracts(aztecNodeConfig.l1RpcUrls[0], hdAccount, logger, {
     ...getL1ContractsConfigEnvVars(),
     genesisArchiveRoot,
-    genesisBlockHash,
     feeJuicePortalInitialBalance: fundingNeeded,
     salt: opts.salt,
     ...deployL1ContractsArgs,
@@ -371,7 +370,7 @@ async function setupFromFresh(
     const rewardDistributor = getContract({
       address: deployL1ContractsValues.l1ContractAddresses.rewardDistributorAddress.toString(),
       abi: l1Artifacts.rewardDistributor.contractAbi,
-      client: deployL1ContractsValues.publicClient,
+      client: deployL1ContractsValues.l1Client,
     });
 
     const blockReward = await rewardDistributor.read.BLOCK_REWARD();
@@ -380,18 +379,18 @@ async function setupFromFresh(
     const feeJuice = getContract({
       address: deployL1ContractsValues.l1ContractAddresses.feeJuiceAddress.toString(),
       abi: l1Artifacts.feeAsset.contractAbi,
-      client: deployL1ContractsValues.walletClient,
+      client: deployL1ContractsValues.l1Client,
     });
 
     const rewardDistributorMintTxHash = await feeJuice.write.mint([rewardDistributor.address, mintAmount], {} as any);
-    await deployL1ContractsValues.publicClient.waitForTransactionReceipt({ hash: rewardDistributorMintTxHash });
+    await deployL1ContractsValues.l1Client.waitForTransactionReceipt({ hash: rewardDistributorMintTxHash });
     logger.info(`Funding rewardDistributor in ${rewardDistributorMintTxHash}`);
   }
 
   const watcher = new AnvilTestWatcher(
     new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls),
     deployL1ContractsValues.l1ContractAddresses.rollupAddress,
-    deployL1ContractsValues.publicClient,
+    deployL1ContractsValues.l1Client,
   );
   await watcher.start();
 
@@ -437,8 +436,8 @@ async function setupFromFresh(
     proverNode = await createAndSyncProverNode(
       `0x${proverNodePrivateKey!.toString('hex')}`,
       aztecNodeConfig,
+      { dataDirectory: path.join(directoryToCleanup, randomBytes(8).toString('hex')) },
       aztecNode,
-      path.join(directoryToCleanup, randomBytes(8).toString('hex')),
       prefilledPublicData,
     );
   }
@@ -522,12 +521,12 @@ async function setupFromState(statePath: string, logger: Logger): Promise<Subsys
   }
 
   logger.verbose('Creating ETH clients...');
-  const { publicClient, walletClient } = createL1Clients(aztecNodeConfig.l1RpcUrls, mnemonicToAccount(MNEMONIC));
+  const l1Client = createExtendedL1Client(aztecNodeConfig.l1RpcUrls, mnemonicToAccount(MNEMONIC));
 
   const watcher = new AnvilTestWatcher(
     new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls),
     aztecNodeConfig.l1Contracts.rollupAddress,
-    publicClient,
+    l1Client,
   );
   await watcher.start();
 
@@ -561,8 +560,8 @@ async function setupFromState(statePath: string, logger: Logger): Promise<Subsys
     proverNode = await createAndSyncProverNode(
       proverNodePrivateKeyHex,
       aztecNodeConfig,
+      { dataDirectory: path.join(directoryToCleanup, randomBytes(8).toString('hex')) },
       aztecNode,
-      path.join(directoryToCleanup, randomBytes(8).toString('hex')),
       prefilledPublicData,
     );
   }
@@ -583,8 +582,7 @@ async function setupFromState(statePath: string, logger: Logger): Promise<Subsys
     bbConfig,
     proverNode,
     deployL1ContractsValues: {
-      walletClient,
-      publicClient,
+      l1Client,
       l1ContractAddresses: aztecNodeConfig.l1Contracts,
     },
     watcher,

package/src/fixtures/utils.ts

@@ -29,14 +29,14 @@ import { SponsoredFeePaymentMethod } from '@aztec/aztec.js/fee/testing';
 import { AnvilTestWatcher, CheatCodes } from '@aztec/aztec.js/testing';
 import { createBlobSinkClient } from '@aztec/blob-sink/client';
 import { type BlobSinkServer, createBlobSinkServer } from '@aztec/blob-sink/server';
-import { GENESIS_ARCHIVE_ROOT, GENESIS_BLOCK_HASH, SPONSORED_FPC_SALT } from '@aztec/constants';
+import { GENESIS_ARCHIVE_ROOT, SPONSORED_FPC_SALT } from '@aztec/constants';
 import { DefaultMultiCallEntrypoint } from '@aztec/entrypoints/multicall';
 import {
   type DeployL1ContractsArgs,
   type DeployL1ContractsReturnType,
   ForwarderContract,
   NULL_KEY,
-  createL1Clients,
+  createExtendedL1Client,
   deployL1Contracts,
   getL1ContractsConfigEnvVars,
   isAnvilTestChain,
@@ -46,8 +46,10 @@ import { DelayedTxUtils, EthCheatCodesWithState, startAnvil } from '@aztec/ether
 import { randomBytes } from '@aztec/foundation/crypto';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
+import { withLogNameSuffix } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
 import { TestDateProvider } from '@aztec/foundation/timer';
+import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { SponsoredFPCContract } from '@aztec/noir-contracts.js/SponsoredFPC';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
@@ -125,7 +127,6 @@ export const setupL1Contracts = async (
     vkTreeRoot: getVKTreeRoot(),
     protocolContractTreeRoot,
     genesisArchiveRoot: args.genesisArchiveRoot ?? new Fr(GENESIS_ARCHIVE_ROOT),
-    genesisBlockHash: args.genesisBlockHash ?? new Fr(GENESIS_BLOCK_HASH),
     salt: args.salt,
     initialValidators: args.initialValidators,
     ...getL1ContractsConfigEnvVars(),
@@ -224,12 +225,11 @@ async function setupWithRemoteEnvironment(
   logger.verbose(`Retrieving contract addresses from ${PXE_URL}`);
   const l1Contracts = (await pxeClient.getNodeInfo()).l1ContractAddresses;
 
-  const { walletClient, publicClient } = createL1Clients(config.l1RpcUrls, account, foundry);
+  const l1Client = createExtendedL1Client(config.l1RpcUrls, account, foundry);
 
   const deployL1ContractsValues: DeployL1ContractsReturnType = {
     l1ContractAddresses: l1Contracts,
-    walletClient,
-    publicClient,
+    l1Client,
   };
   const cheatCodes = await CheatCodes.create(config.l1RpcUrls, pxeClient!);
   const teardown = () => Promise.resolve();
@@ -296,6 +296,8 @@ export type SetupOptions = {
   telemetryConfig?: Partial<TelemetryClientConfig> & { benchmark?: boolean };
   /** Public data that will be inserted in the tree in genesis */
   genesisPublicData?: PublicDataTreeLeaf[];
+  /** Specific config for the prover node, if set. */
+  proverNodeConfig?: Partial<ProverNodeConfig>;
 } & Partial<AztecNodeConfig>;
 
 /** Context for an end-to-end test as returned by the `setup` function */
@@ -425,7 +427,7 @@ export async function setup(
     const initialFundedAccounts =
       opts.initialFundedAccounts ??
       (await generateSchnorrAccounts(opts.numberOfInitialFundedAccounts ?? numberOfAccounts));
-    const { genesisBlockHash, genesisArchiveRoot, prefilledPublicData, fundingNeeded } = await getGenesisValues(
+    const { genesisArchiveRoot, prefilledPublicData, fundingNeeded } = await getGenesisValues(
       initialFundedAccounts.map(a => a.address),
       opts.initialAccountFeeJuice,
       opts.genesisPublicData,
@@ -437,7 +439,7 @@ export async function setup(
         config.l1RpcUrls,
         publisherHdAccount!,
         logger,
-        { ...opts, genesisArchiveRoot, genesisBlockHash, feeJuicePortalInitialBalance: fundingNeeded },
+        { ...opts, genesisArchiveRoot, feeJuicePortalInitialBalance: fundingNeeded },
         chain,
       ));
 
@@ -449,7 +451,7 @@ export async function setup(
       const rewardDistributor = getContract({
         address: deployL1ContractsValues.l1ContractAddresses.rewardDistributorAddress.toString(),
         abi: l1Artifacts.rewardDistributor.contractAbi,
-        client: deployL1ContractsValues.publicClient,
+        client: deployL1ContractsValues.l1Client,
       });
 
       const blockReward = await rewardDistributor.read.BLOCK_REWARD();
@@ -458,11 +460,11 @@ export async function setup(
       const feeJuice = getContract({
         address: deployL1ContractsValues.l1ContractAddresses.feeJuiceAddress.toString(),
         abi: l1Artifacts.feeAsset.contractAbi,
-        client: deployL1ContractsValues.walletClient,
+        client: deployL1ContractsValues.l1Client,
       });
 
       const rewardDistributorMintTxHash = await feeJuice.write.mint([rewardDistributor.address, mintAmount], {} as any);
-      await deployL1ContractsValues.publicClient.waitForTransactionReceipt({ hash: rewardDistributorMintTxHash });
+      await deployL1ContractsValues.l1Client.waitForTransactionReceipt({ hash: rewardDistributorMintTxHash });
       logger.info(`Funding rewardDistributor in ${rewardDistributorMintTxHash}`);
     }
 
@@ -477,7 +479,7 @@ export async function setup(
     const watcher = new AnvilTestWatcher(
       new EthCheatCodesWithState(config.l1RpcUrls),
       deployL1ContractsValues.l1ContractAddresses.rollupAddress,
-      deployL1ContractsValues.publicClient,
+      deployL1ContractsValues.l1Client,
       dateProvider,
     );
 
@@ -516,7 +518,7 @@ export async function setup(
     }
     config.l1PublishRetryIntervalMS = 100;
 
-    const blobSinkClient = createBlobSinkClient(config);
+    const blobSinkClient = createBlobSinkClient(config, { logger: createLogger('node:blob-sink:client') });
     const aztecNode = await AztecNodeService.createAndSync(
       config,
       { dateProvider, blobSinkClient, telemetry },
@@ -534,11 +536,14 @@ export async function setup(
       logger.verbose('Creating and syncing a simulated prover node...');
       const proverNodePrivateKey = getPrivateKeyFromIndex(2);
       const proverNodePrivateKeyHex: Hex = `0x${proverNodePrivateKey!.toString('hex')}`;
+      const proverNodeDataDirectory = path.join(directoryToCleanup, randomBytes(8).toString('hex'));
+      const proverNodeConfig = { ...config.proverNodeConfig, dataDirectory: proverNodeDataDirectory };
       proverNode = await createAndSyncProverNode(
         proverNodePrivateKeyHex,
         config,
+        proverNodeConfig,
         aztecNode,
-        path.join(directoryToCleanup, randomBytes(8).toString('hex')),
+        prefilledPublicData,
       );
     }
 
@@ -776,65 +781,63 @@ export async function waitForProvenChain(node: AztecNode, targetBlock?: number,
   );
 }
 
-export async function createAndSyncProverNode(
+export function createAndSyncProverNode(
   proverNodePrivateKey: `0x${string}`,
   aztecNodeConfig: AztecNodeConfig,
+  proverNodeConfig: Partial<ProverNodeConfig> & Pick<DataStoreConfig, 'dataDirectory'>,
   aztecNode: AztecNode,
-  dataDirectory: string,
   prefilledPublicData: PublicDataTreeLeaf[] = [],
 ) {
-  // Disable stopping the aztec node as the prover coordination test will kill it otherwise
-  // This is only required when stopping the prover node for testing
-  const aztecNodeWithoutStop = {
-    getTxByHash: aztecNode.getTxByHash.bind(aztecNode),
-    getTxsByHash: aztecNode.getTxsByHash.bind(aztecNode),
-    stop: () => Promise.resolve(),
-  };
-
-  const blobSinkClient = createBlobSinkClient(aztecNodeConfig);
-  // Creating temp store and archiver for simulated prover node
-  const archiverConfig = { ...aztecNodeConfig, dataDirectory };
-  const archiver = await createArchiver(archiverConfig, blobSinkClient, {
-    blockUntilSync: true,
-  });
+  return withLogNameSuffix('prover-node', async () => {
+    // Disable stopping the aztec node as the prover coordination test will kill it otherwise
+    // This is only required when stopping the prover node for testing
+    const aztecNodeTxProvider = {
+      getTxByHash: aztecNode.getTxByHash.bind(aztecNode),
+      getTxsByHash: aztecNode.getTxsByHash.bind(aztecNode),
+      stop: () => Promise.resolve(),
+    };
 
-  // Prover node config is for simulated proofs
-  const proverConfig: ProverNodeConfig = {
-    ...aztecNodeConfig,
-    proverCoordinationNodeUrl: undefined,
-    dataDirectory: undefined,
-    realProofs: false,
-    proverAgentCount: 2,
-    publisherPrivateKey: proverNodePrivateKey,
-    proverNodeMaxPendingJobs: 10,
-    proverNodeMaxParallelBlocksPerEpoch: 32,
-    proverNodePollingIntervalMs: 200,
-    txGatheringTimeoutMs: 60000,
-    txGatheringIntervalMs: 1000,
-    txGatheringMaxParallelRequests: 100,
-  };
+    const blobSinkClient = createBlobSinkClient(aztecNodeConfig);
+
+    // Creating temp store and archiver for simulated prover node
+    const archiverConfig = { ...aztecNodeConfig, dataDirectory: proverNodeConfig.dataDirectory };
+    const archiver = await createArchiver(archiverConfig, blobSinkClient, { blockUntilSync: true });
+
+    // Prover node config is for simulated proofs
+    const proverConfig: ProverNodeConfig = {
+      ...aztecNodeConfig,
+      proverCoordinationNodeUrls: [],
+      realProofs: false,
+      proverAgentCount: 2,
+      publisherPrivateKey: proverNodePrivateKey,
+      proverNodeMaxPendingJobs: 10,
+      proverNodeMaxParallelBlocksPerEpoch: 32,
+      proverNodePollingIntervalMs: 200,
+      txGatheringIntervalMs: 1000,
+      txGatheringBatchSize: 10,
+      txGatheringMaxParallelRequestsPerNode: 10,
+      proverNodeFailedEpochStore: undefined,
+      ...proverNodeConfig,
+    };
 
-  const l1TxUtils = createDelayedL1TxUtils(aztecNodeConfig, proverNodePrivateKey, 'prover-node');
+    const l1TxUtils = createDelayedL1TxUtils(aztecNodeConfig, proverNodePrivateKey, 'prover-node');
 
-  const proverNode = await createProverNode(
-    proverConfig,
-    {
-      aztecNodeTxProvider: aztecNodeWithoutStop,
-      archiver: archiver as Archiver,
-      l1TxUtils,
-    },
-    { prefilledPublicData },
-  );
-  getLogger().info(`Created and synced prover node`, { publisherAddress: l1TxUtils.walletClient.account.address });
-  proverNode.start();
-  return proverNode;
+    const proverNode = await createProverNode(
+      proverConfig,
+      { aztecNodeTxProvider, archiver: archiver as Archiver, l1TxUtils },
+      { prefilledPublicData },
+    );
+    getLogger().info(`Created and synced prover node`, { publisherAddress: l1TxUtils.client.account!.address });
+    await proverNode.start();
+    return proverNode;
+  });
 }
 
 function createDelayedL1TxUtils(aztecNodeConfig: AztecNodeConfig, privateKey: `0x${string}`, logName: string) {
-  const { publicClient, walletClient } = createL1Clients(aztecNodeConfig.l1RpcUrls, privateKey, foundry);
+  const l1Client = createExtendedL1Client(aztecNodeConfig.l1RpcUrls, privateKey, foundry);
 
   const log = createLogger(logName);
-  const l1TxUtils = new DelayedTxUtils(publicClient, walletClient, log, aztecNodeConfig);
+  const l1TxUtils = new DelayedTxUtils(l1Client, log, aztecNodeConfig);
   l1TxUtils.enableDelayer(aztecNodeConfig.ethereumSlotDuration);
   return l1TxUtils;
 }
@@ -844,11 +847,10 @@ export async function createForwarderContract(
   privateKey: `0x${string}`,
   rollupAddress: Hex,
 ) {
-  const { walletClient, publicClient } = createL1Clients(aztecNodeConfig.l1RpcUrls, privateKey, foundry);
+  const l1Client = createExtendedL1Client(aztecNodeConfig.l1RpcUrls, privateKey, foundry);
   const forwarderContract = await ForwarderContract.create(
-    walletClient.account.address,
-    walletClient,
-    publicClient,
+    l1Client.account.address,
+    l1Client,
     createLogger('forwarder'),
     rollupAddress,
   );