@aztec/end-to-end 0.0.0-test.1 → 0.0.1-fake-ceab37513c

package/src/fixtures/utils.ts

@@ -9,55 +9,80 @@ import {
 import { type Archiver, createArchiver } from '@aztec/archiver';
 import { type AztecNodeConfig, AztecNodeService, getConfigEnvVars } from '@aztec/aztec-node';
 import {
+  AccountManager,
   type AccountWalletWithSecretKey,
-  AnvilTestWatcher,
   type AztecAddress,
   type AztecNode,
   BatchCall,
-  CheatCodes,
   type ContractMethod,
-  type DeployL1ContractsReturnType,
-  FeeJuicePaymentMethod,
   type Logger,
   type PXE,
-  SignerlessWallet,
   type Wallet,
   createAztecNodeClient,
   createLogger,
   createPXEClient,
-  deployL1Contracts,
   makeFetch,
+  sleep,
   waitForPXE,
 } from '@aztec/aztec.js';
-import { deployInstance, registerContractClass } from '@aztec/aztec.js/deployment';
-import type { BBNativePrivateKernelProver } from '@aztec/bb-prover';
+import { publishContractClass, publishInstance } from '@aztec/aztec.js/deployment';
+import { AnvilTestWatcher, CheatCodes } from '@aztec/aztec/testing';
 import { createBlobSinkClient } from '@aztec/blob-sink/client';
 import { type BlobSinkServer, createBlobSinkServer } from '@aztec/blob-sink/server';
-import { FEE_JUICE_INITIAL_MINT, GENESIS_ARCHIVE_ROOT, GENESIS_BLOCK_HASH } from '@aztec/constants';
+import { GENESIS_ARCHIVE_ROOT, SPONSORED_FPC_SALT } from '@aztec/constants';
 import {
   type DeployL1ContractsArgs,
-  ForwarderContract,
+  type DeployL1ContractsReturnType,
+  FeeAssetArtifact,
   NULL_KEY,
-  createL1Clients,
+  type Operator,
+  RollupContract,
+  createExtendedL1Client,
+  deployL1Contracts,
+  deployMulticall3,
   getL1ContractsConfigEnvVars,
   isAnvilTestChain,
-  l1Artifacts,
 } from '@aztec/ethereum';
-import { DelayedTxUtils, EthCheatCodesWithState, startAnvil } from '@aztec/ethereum/test';
+import {
+  DelayedTxUtils,
+  EthCheatCodes,
+  EthCheatCodesWithState,
+  createDelayedL1TxUtilsFromViemWallet,
+  startAnvil,
+} from '@aztec/ethereum/test';
+import { SecretValue } from '@aztec/foundation/config';
 import { randomBytes } from '@aztec/foundation/crypto';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
+import { tryRmDir } from '@aztec/foundation/fs';
+import { withLogNameSuffix } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
-import { TestDateProvider } from '@aztec/foundation/timer';
-import { FeeJuiceContract } from '@aztec/noir-contracts.js/FeeJuice';
+import { DateProvider, 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 { ProtocolContractAddress, protocolContractTreeRoot } from '@aztec/protocol-contracts';
-import { type ProverNode, type ProverNodeConfig, createProverNode } from '@aztec/prover-node';
-import { type PXEService, type PXEServiceConfig, createPXEService, getPXEServiceConfig } from '@aztec/pxe/server';
+import type { P2PClientDeps } from '@aztec/p2p';
+import { MockGossipSubNetwork, getMockPubSubP2PServiceFactory } from '@aztec/p2p/test-helpers';
+import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { type ProverNode, type ProverNodeConfig, type ProverNodeDeps, createProverNode } from '@aztec/prover-node';
+import {
+  type PXEService,
+  type PXEServiceConfig,
+  createPXEServiceWithSimulator,
+  getPXEServiceConfig,
+} from '@aztec/pxe/server';
 import type { SequencerClient } from '@aztec/sequencer-client';
 import type { TestSequencerClient } from '@aztec/sequencer-client/test';
-import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
-import { Gas } from '@aztec/stdlib/gas';
+import { MemoryCircuitRecorder, SimulatorRecorderWrapper, WASMSimulator } from '@aztec/simulator/client';
+import { FileCircuitRecorder } from '@aztec/simulator/testing';
+import {
+  type ContractInstanceWithAddress,
+  getContractClassFromArtifact,
+  getContractInstanceFromInstantiationParams,
+} from '@aztec/stdlib/contract';
+import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
+import { tryStop } from '@aztec/stdlib/interfaces/server';
+import type { P2PClientType } from '@aztec/stdlib/p2p';
 import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
 import {
   type TelemetryClient,
@@ -73,9 +98,8 @@ import fs from 'fs/promises';
 import getPort from 'get-port';
 import { tmpdir } from 'os';
 import * as path from 'path';
-import { inspect } from 'util';
 import { type Chain, type HDAccount, type Hex, type PrivateKeyAccount, getContract } from 'viem';
-import { mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
+import { generatePrivateKey, mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
 import { foundry } from 'viem/chains';
 
 import { MNEMONIC, TEST_PEER_CHECK_INTERVAL_MS } from './fixtures.js';
@@ -117,14 +141,13 @@ export const setupL1Contracts = async (
   chain: Chain = foundry,
 ) => {
   const l1Data = await deployL1Contracts(l1RpcUrls, account, chain, logger, {
-    l2FeeJuiceAddress: ProtocolContractAddress.FeeJuice.toField(),
     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(),
+    realVerifier: false,
     ...args,
   });
 
@@ -135,18 +158,15 @@ export const setupL1Contracts = async (
  * Sets up Private eXecution Environment (PXE).
  * @param aztecNode - An instance of Aztec Node.
  * @param opts - Partial configuration for the PXE service.
- * @param firstPrivKey - The private key of the first account to be created.
  * @param logger - The logger to be used.
  * @param useLogSuffix - Whether to add a randomly generated suffix to the PXE debug logs.
- * @param proofCreator - An optional proof creator to use
- * @returns Private eXecution Environment (PXE), accounts, wallets and logger.
+ * @returns Private eXecution Environment (PXE), logger and teardown function.
  */
 export async function setupPXEService(
   aztecNode: AztecNode,
   opts: Partial<PXEServiceConfig> = {},
   logger = getLogger(),
   useLogSuffix = false,
-  proofCreator?: BBNativePrivateKernelProver,
 ): Promise<{
   /**
    * The PXE instance.
@@ -162,6 +182,8 @@ export async function setupPXEService(
   teardown: () => Promise<void>;
 }> {
   const pxeServiceConfig = { ...getPXEServiceConfig(), ...opts };
+  // For tests we only want proving enabled if specifically requested
+  pxeServiceConfig.proverEnabled = !!opts.proverEnabled;
 
   // If no data directory provided, create a temp directory and clean up afterwards
   const configuredDataDirectory = pxeServiceConfig.dataDirectory;
@@ -169,17 +191,16 @@ export async function setupPXEService(
     pxeServiceConfig.dataDirectory = path.join(tmpdir(), randomBytes(8).toString('hex'));
   }
 
-  const pxe = await createPXEService(aztecNode, pxeServiceConfig, useLogSuffix, proofCreator);
+  const simulator = new WASMSimulator();
+  const recorder = process.env.CIRCUIT_RECORD_DIR
+    ? new FileCircuitRecorder(process.env.CIRCUIT_RECORD_DIR)
+    : new MemoryCircuitRecorder();
+  const simulatorWithRecorder = new SimulatorRecorderWrapper(simulator, recorder);
+  const pxe = await createPXEServiceWithSimulator(aztecNode, simulatorWithRecorder, pxeServiceConfig, {
+    useLogSuffix,
+  });
 
-  const teardown = async () => {
-    if (!configuredDataDirectory) {
-      try {
-        await fs.rm(pxeServiceConfig.dataDirectory!, { recursive: true, force: true, maxRetries: 3 });
-      } catch (err) {
-        logger.warn(`Failed to delete tmp PXE data directory ${pxeServiceConfig.dataDirectory}: ${err}`);
-      }
-    }
-  };
+  const teardown = configuredDataDirectory ? () => Promise.resolve() : () => tryRmDir(pxeServiceConfig.dataDirectory!);
 
   return {
     pxe,
@@ -202,7 +223,7 @@ async function setupWithRemoteEnvironment(
   config: AztecNodeConfig,
   logger: Logger,
   numberOfAccounts: number,
-) {
+): Promise<EndToEndContext> {
   // we are setting up against a remote environment, l1 contracts are already deployed
   const aztecNodeUrl = getAztecUrl();
   logger.verbose(`Creating Aztec Node client to remote host ${aztecNodeUrl}`);
@@ -212,20 +233,19 @@ async function setupWithRemoteEnvironment(
   await waitForPXE(pxeClient, logger);
   logger.verbose('JSON RPC client connected to PXE');
   logger.verbose(`Retrieving contract addresses from ${PXE_URL}`);
-  const l1Contracts = (await pxeClient.getNodeInfo()).l1ContractAddresses;
+  const { l1ContractAddresses, rollupVersion } = await pxeClient.getNodeInfo();
 
-  const { walletClient, publicClient } = createL1Clients(config.l1RpcUrls, account, foundry);
+  const l1Client = createExtendedL1Client(config.l1RpcUrls, account, foundry);
 
   const deployL1ContractsValues: DeployL1ContractsReturnType = {
-    l1ContractAddresses: l1Contracts,
-    walletClient,
-    publicClient,
+    l1ContractAddresses,
+    l1Client,
+    rollupVersion,
   };
+  const ethCheatCodes = new EthCheatCodes(config.l1RpcUrls);
   const cheatCodes = await CheatCodes.create(config.l1RpcUrls, pxeClient!);
   const teardown = () => Promise.resolve();
 
-  await setupCanonicalFeeJuice(pxeClient);
-
   logger.verbose('Constructing available wallets from already registered accounts...');
   const initialFundedAccounts = await getDeployedTestAccounts(pxeClient);
   const wallets = await getDeployedTestAccountsWallets(pxeClient);
@@ -237,17 +257,21 @@ async function setupWithRemoteEnvironment(
 
   return {
     aztecNode,
+    aztecNodeAdmin: undefined,
     sequencer: undefined,
     proverNode: undefined,
     pxe: pxeClient,
     deployL1ContractsValues,
-    accounts: await pxeClient!.getRegisteredAccounts(),
     config,
     initialFundedAccounts,
+    wallets,
     wallet: wallets[0],
-    wallets: wallets.slice(0, numberOfAccounts),
+    accounts: wallets.slice(0, numberOfAccounts).map(w => w.getAddress()),
     logger,
     cheatCodes,
+    ethCheatCodes,
+    prefilledPublicData: undefined,
+    mockGossipSubNetwork: undefined,
     watcher: undefined,
     dateProvider: undefined,
     blobSink: undefined,
@@ -275,7 +299,7 @@ export type SetupOptions = {
   /** Salt to use in L1 contract deployment */
   salt?: number;
   /** An initial set of validators */
-  initialValidators?: EthAddress[];
+  initialValidators?: (Operator & { privateKey: `0x${string}` })[];
   /** Anvil Start time */
   l1StartTime?: number;
   /** The anvil time where we should at the earliest be seeing L2 blocks */
@@ -288,12 +312,28 @@ 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>;
+  /** Whether to use a mock gossip sub network for p2p clients. */
+  mockGossipSubNetwork?: boolean;
+  /** Whether to disable the anvil test watcher (can still be manually started) */
+  disableAnvilTestWatcher?: boolean;
+  /** Whether to enable anvil automine during deployment of L1 contracts (consider defaulting this to true). */
+  automineL1Setup?: boolean;
+  /** How many accounts to seed and unlock in anvil. */
+  anvilAccounts?: number;
+  /** Port to start anvil (defaults to 8545) */
+  anvilPort?: number;
+  /** Key to use for publishing L1 contracts */
+  l1PublisherKey?: SecretValue<`0x${string}`>;
 } & Partial<AztecNodeConfig>;
 
 /** Context for an end-to-end test as returned by the `setup` function */
 export type EndToEndContext = {
   /** The Aztec Node service or client a connected to it. */
   aztecNode: AztecNode;
+  /** Client to the Aztec Node admin interface (undefined if connected to remote environment) */
+  aztecNodeAdmin?: AztecNodeAdmin;
   /** The prover node service (only set if startProverNode is true) */
   proverNode: ProverNode | undefined;
   /** A client to the sequencer service (undefined if connected to remote environment) */
@@ -306,14 +346,18 @@ export type EndToEndContext = {
   config: AztecNodeConfig;
   /** The data for the initial funded accounts. */
   initialFundedAccounts: InitialAccountData[];
+  /* Wallets created for the initial funded accounts, with secret keys. */
+  wallets: AccountWalletWithSecretKey[];
   /** The first wallet to be used. */
   wallet: AccountWalletWithSecretKey;
-  /** The wallets to be used. */
-  wallets: AccountWalletWithSecretKey[];
+  /** The accounts to be used. */
+  accounts: AztecAddress[];
   /** Logger instance named as the current test. */
   logger: Logger;
   /** The cheat codes. */
   cheatCodes: CheatCodes;
+  /** The cheat codes for L1 */
+  ethCheatCodes: EthCheatCodes;
   /** The anvil test watcher (undefined if connected to remote environment) */
   watcher: AnvilTestWatcher | undefined;
   /** Allows tweaking current system time, used by the epoch cache only (undefined if connected to remote environment) */
@@ -322,6 +366,10 @@ export type EndToEndContext = {
   blobSink: BlobSinkServer | undefined;
   /** Telemetry client */
   telemetryClient: TelemetryClient | undefined;
+  /** Mock gossip sub network used for gossipping messages (only if mockGossipSubNetwork was set to true in opts) */
+  mockGossipSubNetwork: MockGossipSubNetwork | undefined;
+  /** Prefilled public data used for setting up nodes. */
+  prefilledPublicData: PublicDataTreeLeaf[] | undefined;
   /** Function to stop the started services. */
   teardown: () => Promise<void>;
 };
@@ -334,267 +382,375 @@ export type EndToEndContext = {
  */
 export async function setup(
   numberOfAccounts = 1,
-  opts: SetupOptions = {
-    customForwarderContractAddress: EthAddress.ZERO,
-  },
+  opts: SetupOptions = {},
   pxeOpts: Partial<PXEServiceConfig> = {},
   chain: Chain = foundry,
 ): Promise<EndToEndContext> {
-  const config = { ...getConfigEnvVars(), ...opts };
-  config.peerCheckIntervalMS = TEST_PEER_CHECK_INTERVAL_MS;
-
-  const logger = getLogger();
-
-  // Create a temp directory for any services that need it and cleanup later
-  const directoryToCleanup = path.join(tmpdir(), randomBytes(8).toString('hex'));
-  await fs.mkdir(directoryToCleanup, { recursive: true });
-  if (!config.dataDirectory) {
-    config.dataDirectory = directoryToCleanup;
-  }
-
   let anvil: Anvil | undefined;
-
-  if (!config.l1RpcUrls?.length) {
-    if (!isAnvilTestChain(chain.id)) {
-      throw new Error(`No ETHEREUM_HOSTS set but non anvil chain requested`);
-    }
-    if (PXE_URL) {
-      throw new Error(
-        `PXE_URL provided but no ETHEREUM_HOSTS set. Refusing to run, please set both variables so tests can deploy L1 contracts to the same Anvil instance`,
-      );
+  try {
+    opts.aztecTargetCommitteeSize ??= 0;
+    opts.slasherFlavor ??= 'none';
+
+    const config: AztecNodeConfig & SetupOptions = { ...getConfigEnvVars(), ...opts };
+    // use initialValidators for the node config
+    config.validatorPrivateKeys = new SecretValue(opts.initialValidators?.map(v => v.privateKey) ?? []);
+
+    config.peerCheckIntervalMS = TEST_PEER_CHECK_INTERVAL_MS;
+    // For tests we only want proving enabled if specifically requested
+    config.realProofs = !!opts.realProofs;
+    // Only enforce the time table if requested
+    config.enforceTimeTable = !!opts.enforceTimeTable;
+
+    const logger = getLogger();
+
+    // Create a temp directory for any services that need it and cleanup later
+    const directoryToCleanup = path.join(tmpdir(), randomBytes(8).toString('hex'));
+    await fs.mkdir(directoryToCleanup, { recursive: true });
+    if (!config.dataDirectory) {
+      config.dataDirectory = directoryToCleanup;
     }
 
-    const res = await startAnvil({ l1BlockTime: opts.ethereumSlotDuration });
-    anvil = res.anvil;
-    config.l1RpcUrls = [res.rpcUrl];
-  }
+    if (!config.l1RpcUrls?.length) {
+      if (!isAnvilTestChain(chain.id)) {
+        throw new Error(`No ETHEREUM_HOSTS set but non anvil chain requested`);
+      }
+      if (PXE_URL) {
+        throw new Error(
+          `PXE_URL provided but no ETHEREUM_HOSTS set. Refusing to run, please set both variables so tests can deploy L1 contracts to the same Anvil instance`,
+        );
+      }
 
-  // Enable logging metrics to a local file named after the test suite
-  if (isMetricsLoggingRequested()) {
-    const filename = path.join('log', getJobName() + '.jsonl');
-    logger.info(`Logging metrics to ${filename}`);
-    setupMetricsLogger(filename);
-  }
+      const res = await startAnvil({
+        l1BlockTime: opts.ethereumSlotDuration,
+        accounts: opts.anvilAccounts,
+        port: opts.anvilPort,
+      });
+      anvil = res.anvil;
+      config.l1RpcUrls = [res.rpcUrl];
+    }
 
-  const ethCheatCodes = new EthCheatCodesWithState(config.l1RpcUrls);
+    // Enable logging metrics to a local file named after the test suite
+    if (isMetricsLoggingRequested()) {
+      const filename = path.join('log', getJobName() + '.jsonl');
+      logger.info(`Logging metrics to ${filename}`);
+      setupMetricsLogger(filename);
+    }
 
-  if (opts.stateLoad) {
-    await ethCheatCodes.loadChainState(opts.stateLoad);
-  }
+    const ethCheatCodes = new EthCheatCodesWithState(config.l1RpcUrls);
 
-  if (opts.l1StartTime) {
-    await ethCheatCodes.warp(opts.l1StartTime);
-  }
+    if (opts.stateLoad) {
+      await ethCheatCodes.loadChainState(opts.stateLoad);
+    }
 
-  let publisherPrivKey = undefined;
-  let publisherHdAccount = undefined;
-
-  if (config.publisherPrivateKey && config.publisherPrivateKey != NULL_KEY) {
-    publisherHdAccount = privateKeyToAccount(config.publisherPrivateKey);
-  } else if (!MNEMONIC) {
-    throw new Error(`Mnemonic not provided and no publisher private key`);
-  } else {
-    publisherHdAccount = mnemonicToAccount(MNEMONIC, { addressIndex: 0 });
-    const publisherPrivKeyRaw = publisherHdAccount.getHdKey().privateKey;
-    publisherPrivKey = publisherPrivKeyRaw === null ? null : Buffer.from(publisherPrivKeyRaw);
-    config.publisherPrivateKey = `0x${publisherPrivKey!.toString('hex')}`;
-  }
+    if (opts.l1StartTime) {
+      await ethCheatCodes.warp(opts.l1StartTime, { resetBlockInterval: true });
+    }
 
-  // Made as separate values such that keys can change, but for test they will be the same.
-  config.validatorPrivateKey = config.publisherPrivateKey;
+    let publisherPrivKey = undefined;
+    let publisherHdAccount = undefined;
+
+    if (opts.l1PublisherKey && opts.l1PublisherKey.getValue() && opts.l1PublisherKey.getValue() != NULL_KEY) {
+      publisherHdAccount = privateKeyToAccount(opts.l1PublisherKey.getValue());
+    } else if (
+      config.publisherPrivateKeys &&
+      config.publisherPrivateKeys.length > 0 &&
+      config.publisherPrivateKeys[0].getValue() != NULL_KEY
+    ) {
+      publisherHdAccount = privateKeyToAccount(config.publisherPrivateKeys[0].getValue());
+    } else if (!MNEMONIC) {
+      throw new Error(`Mnemonic not provided and no publisher private key`);
+    } else {
+      publisherHdAccount = mnemonicToAccount(MNEMONIC, { addressIndex: 0 });
+      const publisherPrivKeyRaw = publisherHdAccount.getHdKey().privateKey;
+      publisherPrivKey = publisherPrivKeyRaw === null ? null : Buffer.from(publisherPrivKeyRaw);
+      config.publisherPrivateKeys = [new SecretValue(`0x${publisherPrivKey!.toString('hex')}` as const)];
+    }
 
-  if (PXE_URL) {
-    // we are setting up against a remote environment, l1 contracts are assumed to already be deployed
-    return await setupWithRemoteEnvironment(publisherHdAccount!, config, logger, numberOfAccounts);
-  }
+    config.coinbase = EthAddress.fromString(publisherHdAccount.address);
 
-  // Blob sink service - blobs get posted here and served from here
-  const blobSinkPort = await getPort();
-  const blobSink = await createBlobSinkServer({ port: blobSinkPort });
-  await blobSink.start();
-  config.blobSinkUrl = `http://localhost:${blobSinkPort}`;
-
-  const initialFundedAccounts =
-    opts.initialFundedAccounts ??
-    (await generateSchnorrAccounts(opts.numberOfInitialFundedAccounts ?? numberOfAccounts));
-  const { genesisBlockHash, genesisArchiveRoot, prefilledPublicData } = await getGenesisValues(
-    initialFundedAccounts.map(a => a.address),
-    opts.initialAccountFeeJuice,
-    opts.genesisPublicData,
-  );
+    if (PXE_URL) {
+      // we are setting up against a remote environment, l1 contracts are assumed to already be deployed
+      return await setupWithRemoteEnvironment(publisherHdAccount!, config, logger, numberOfAccounts);
+    }
 
-  const deployL1ContractsValues =
-    opts.deployL1ContractsValues ??
-    (await setupL1Contracts(
-      config.l1RpcUrls,
-      publisherHdAccount!,
-      logger,
-      { ...opts, genesisArchiveRoot, genesisBlockHash },
-      chain,
-    ));
+    const initialFundedAccounts =
+      opts.initialFundedAccounts ??
+      (await generateSchnorrAccounts(opts.numberOfInitialFundedAccounts ?? numberOfAccounts));
+    const { genesisArchiveRoot, prefilledPublicData, fundingNeeded } = await getGenesisValues(
+      initialFundedAccounts.map(a => a.address),
+      opts.initialAccountFeeJuice,
+      opts.genesisPublicData,
+    );
 
-  config.l1Contracts = deployL1ContractsValues.l1ContractAddresses;
+    const wasAutomining = await ethCheatCodes.isAutoMining();
+    const enableAutomine = opts.automineL1Setup && !wasAutomining && isAnvilTestChain(chain.id);
+    if (enableAutomine) {
+      await ethCheatCodes.setAutomine(true);
+    }
 
-  if (opts.fundRewardDistributor) {
-    // Mints block rewards for 10000 blocks to the rewardDistributor contract
+    const l1Client = createExtendedL1Client(config.l1RpcUrls, publisherHdAccount!, chain);
+    await deployMulticall3(l1Client, logger);
+
+    const deployL1ContractsValues =
+      opts.deployL1ContractsValues ??
+      (await setupL1Contracts(
+        config.l1RpcUrls,
+        publisherHdAccount!,
+        logger,
+        {
+          ...opts,
+          genesisArchiveRoot,
+          feeJuicePortalInitialBalance: fundingNeeded,
+          initialValidators: opts.initialValidators,
+        },
+        chain,
+      ));
+
+    config.l1Contracts = deployL1ContractsValues.l1ContractAddresses;
+    config.rollupVersion = deployL1ContractsValues.rollupVersion;
+
+    if (opts.fundRewardDistributor) {
+      // Mints block rewards for 10000 blocks to the rewardDistributor contract
+
+      const rollup = new RollupContract(
+        deployL1ContractsValues.l1Client,
+        deployL1ContractsValues.l1ContractAddresses.rollupAddress,
+      );
 
-    const rewardDistributor = getContract({
-      address: deployL1ContractsValues.l1ContractAddresses.rewardDistributorAddress.toString(),
-      abi: l1Artifacts.rewardDistributor.contractAbi,
-      client: deployL1ContractsValues.publicClient,
-    });
+      const blockReward = await rollup.getBlockReward();
+      const mintAmount = 10_000n * (blockReward as bigint);
 
-    const blockReward = await rewardDistributor.read.BLOCK_REWARD();
-    const mintAmount = 10_000n * (blockReward as bigint);
+      const feeJuice = getContract({
+        address: deployL1ContractsValues.l1ContractAddresses.feeJuiceAddress.toString(),
+        abi: FeeAssetArtifact.contractAbi,
+        client: deployL1ContractsValues.l1Client,
+      });
 
-    const feeJuice = getContract({
-      address: deployL1ContractsValues.l1ContractAddresses.feeJuiceAddress.toString(),
-      abi: l1Artifacts.feeAsset.contractAbi,
-      client: deployL1ContractsValues.walletClient,
-    });
+      const rewardDistributorMintTxHash = await feeJuice.write.mint(
+        [deployL1ContractsValues.l1ContractAddresses.rewardDistributorAddress.toString(), mintAmount],
+        {} as any,
+      );
+      await deployL1ContractsValues.l1Client.waitForTransactionReceipt({ hash: rewardDistributorMintTxHash });
+      logger.info(`Funding rewardDistributor in ${rewardDistributorMintTxHash}`);
+    }
 
-    const rewardDistributorMintTxHash = await feeJuice.write.mint([rewardDistributor.address, mintAmount], {} as any);
-    await deployL1ContractsValues.publicClient.waitForTransactionReceipt({ hash: rewardDistributorMintTxHash });
-    logger.info(`Funding rewardDistributor in ${rewardDistributorMintTxHash}`);
-  }
+    if (enableAutomine) {
+      await ethCheatCodes.setAutomine(false);
+      await ethCheatCodes.setIntervalMining(config.ethereumSlotDuration);
+    }
 
-  if (opts.l2StartTime) {
-    // This should only be used in synching test or when you need to have a stable
-    // timestamp for the first l2 block.
-    await ethCheatCodes.warp(opts.l2StartTime);
-  }
+    if (opts.l2StartTime) {
+      // This should only be used in synching test or when you need to have a stable
+      // timestamp for the first l2 block.
+      await ethCheatCodes.warp(opts.l2StartTime, { resetBlockInterval: true });
+    }
 
-  const dateProvider = new TestDateProvider();
+    const dateProvider = new TestDateProvider();
+    dateProvider.setTime((await ethCheatCodes.timestamp()) * 1000);
 
-  const watcher = new AnvilTestWatcher(
-    new EthCheatCodesWithState(config.l1RpcUrls),
-    deployL1ContractsValues.l1ContractAddresses.rollupAddress,
-    deployL1ContractsValues.publicClient,
-    dateProvider,
-  );
+    const watcher = new AnvilTestWatcher(
+      new EthCheatCodesWithState(config.l1RpcUrls),
+      deployL1ContractsValues.l1ContractAddresses.rollupAddress,
+      deployL1ContractsValues.l1Client,
+      dateProvider,
+    );
+    if (!opts.disableAnvilTestWatcher) {
+      await watcher.start();
+    }
 
-  await watcher.start();
+    const telemetry = getTelemetryClient(opts.telemetryConfig);
+
+    // Blob sink service - blobs get posted here and served from here
+    const blobSinkPort = await getPort();
+    const blobSink = await createBlobSinkServer(
+      {
+        l1ChainId: config.l1ChainId,
+        l1RpcUrls: config.l1RpcUrls,
+        l1Contracts: config.l1Contracts,
+        port: blobSinkPort,
+        dataDirectory: config.dataDirectory,
+        dataStoreMapSizeKb: config.dataStoreMapSizeKb,
+      },
+      telemetry,
+    );
+    await blobSink.start();
+    config.blobSinkUrl = `http://localhost:${blobSinkPort}`;
 
-  logger.verbose('Creating and synching an aztec node...');
+    logger.verbose('Creating and synching an aztec node', config);
 
-  const acvmConfig = await getACVMConfig(logger);
-  if (acvmConfig) {
-    config.acvmWorkingDirectory = acvmConfig.acvmWorkingDirectory;
-    config.acvmBinaryPath = acvmConfig.acvmBinaryPath;
-  }
+    const acvmConfig = await getACVMConfig(logger);
+    if (acvmConfig) {
+      config.acvmWorkingDirectory = acvmConfig.acvmWorkingDirectory;
+      config.acvmBinaryPath = acvmConfig.acvmBinaryPath;
+    }
 
-  const bbConfig = await getBBConfig(logger);
-  if (bbConfig) {
-    config.bbBinaryPath = bbConfig.bbBinaryPath;
-    config.bbWorkingDirectory = bbConfig.bbWorkingDirectory;
-  }
-  config.l1PublishRetryIntervalMS = 100;
+    const bbConfig = await getBBConfig(logger);
+    if (bbConfig) {
+      config.bbBinaryPath = bbConfig.bbBinaryPath;
+      config.bbWorkingDirectory = bbConfig.bbWorkingDirectory;
+    }
 
-  const telemetry = getTelemetryClient(opts.telemetryConfig);
+    const blobSinkClient = createBlobSinkClient(config, { logger: createLogger('node:blob-sink:client') });
 
-  const blobSinkClient = createBlobSinkClient(config);
-  const aztecNode = await AztecNodeService.createAndSync(
-    config,
-    {
-      dateProvider,
-      blobSinkClient,
-    },
-    { prefilledPublicData },
-  );
-  const sequencer = aztecNode.getSequencer();
+    let mockGossipSubNetwork: MockGossipSubNetwork | undefined;
+    let p2pClientDeps: P2PClientDeps<P2PClientType.Full> | undefined = undefined;
 
-  if (sequencer) {
-    const publisher = (sequencer as TestSequencerClient).sequencer.publisher;
-    publisher.l1TxUtils = DelayedTxUtils.fromL1TxUtils(publisher.l1TxUtils, config.ethereumSlotDuration);
-  }
+    if (opts.mockGossipSubNetwork) {
+      mockGossipSubNetwork = new MockGossipSubNetwork();
+      p2pClientDeps = { p2pServiceFactory: getMockPubSubP2PServiceFactory(mockGossipSubNetwork) };
+    }
 
-  let proverNode: ProverNode | undefined = undefined;
-  if (opts.startProverNode) {
-    logger.verbose('Creating and syncing a simulated prover node...');
-    const proverNodePrivateKey = getPrivateKeyFromIndex(2);
-    const proverNodePrivateKeyHex: Hex = `0x${proverNodePrivateKey!.toString('hex')}`;
-    proverNode = await createAndSyncProverNode(
-      proverNodePrivateKeyHex,
-      config,
-      aztecNode,
-      path.join(directoryToCleanup, randomBytes(8).toString('hex')),
-    );
-  }
+    // Transactions built against the genesis state must be included in block 1, otherwise they are dropped.
+    // To avoid test failures from dropped transactions, we ensure progression beyond genesis before proceeding.
+    // For account deployments, we set minTxsPerBlock=1 and deploy accounts sequentially for guaranteed success.
+    // If no accounts need deployment, we await an empty block to confirm network progression. After either path
+    // completes, we restore the original minTxsPerBlock setting. The deployment and waiting for empty block is
+    // handled by the if-else branches on line 632.
+    // For more details on why the tx would be dropped see `validate_include_by_timestamp` function in
+    // `noir-projects/noir-protocol-circuits/crates/rollup-lib/src/base/components/validation_requests.nr`.
+    //
+    // Note: If the following seems too convoluted or if it starts making problems, we could drop the "progressing
+    // past genesis via an account contract deployment" optimization and just call flush() on the sequencer and wait
+    // for an empty block to be mined. This would simplify it all quite a bit but the setup would be slower for tests
+    // deploying accounts.
+    const originalMinTxsPerBlock = config.minTxsPerBlock;
+    if (originalMinTxsPerBlock === undefined) {
+      throw new Error('minTxsPerBlock is undefined in e2e test setup');
+    }
+    config.minTxsPerBlock = numberOfAccounts === 0 ? 0 : 1;
 
-  logger.verbose('Creating a pxe...');
-  const { pxe, teardown: pxeTeardown } = await setupPXEService(aztecNode!, pxeOpts, logger);
+    config.p2pEnabled = opts.mockGossipSubNetwork || config.p2pEnabled;
+    config.p2pIp = opts.p2pIp ?? config.p2pIp ?? '127.0.0.1';
 
-  if (!config.skipProtocolContracts) {
-    logger.verbose('Setting up Fee Juice...');
-    await setupCanonicalFeeJuice(pxe);
-  }
+    if (!config.disableValidator) {
+      if ((config.validatorPrivateKeys?.getValue().length ?? 0) === 0) {
+        config.validatorPrivateKeys = new SecretValue([generatePrivateKey()]);
+      }
+    }
 
-  const accountManagers = await deployFundedSchnorrAccounts(pxe, initialFundedAccounts.slice(0, numberOfAccounts));
-  const wallets = await Promise.all(accountManagers.map(account => account.getWallet()));
-  if (initialFundedAccounts.length < numberOfAccounts) {
-    // TODO: Create (numberOfAccounts - initialFundedAccounts.length) wallets without funds.
-    throw new Error(
-      `Unable to deploy ${numberOfAccounts} accounts. Only ${initialFundedAccounts.length} accounts were funded.`,
+    const aztecNode = await AztecNodeService.createAndSync(
+      config, // REFACTOR: createAndSync mutates this config
+      { dateProvider, blobSinkClient, telemetry, p2pClientDeps, logger: createLogger('node:MAIN-aztec-node') },
+      { prefilledPublicData },
     );
-  }
-
-  const cheatCodes = await CheatCodes.create(config.l1RpcUrls, pxe!);
-
-  const teardown = async () => {
-    await pxeTeardown();
+    const sequencerClient = aztecNode.getSequencer();
 
-    if (aztecNode instanceof AztecNodeService) {
-      await aztecNode?.stop();
+    if (sequencerClient) {
+      const publisher = (sequencerClient as TestSequencerClient).sequencer.publisher;
+      publisher.l1TxUtils = DelayedTxUtils.fromL1TxUtils(publisher.l1TxUtils, config.ethereumSlotDuration, l1Client);
     }
 
-    if (proverNode) {
-      await proverNode.stop();
+    let proverNode: ProverNode | undefined = undefined;
+    if (opts.startProverNode) {
+      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,
+        prefilledPublicData,
+      );
     }
 
-    if (acvmConfig?.cleanup) {
-      // remove the temp directory created for the acvm
-      logger.verbose(`Cleaning up ACVM state`);
-      await acvmConfig.cleanup();
+    logger.verbose('Creating a pxe...');
+    const { pxe, teardown: pxeTeardown } = await setupPXEService(aztecNode!, pxeOpts, logger);
+
+    const cheatCodes = await CheatCodes.create(config.l1RpcUrls, pxe!);
+
+    if (
+      (opts.aztecTargetCommitteeSize && opts.aztecTargetCommitteeSize > 0) ||
+      (opts.initialValidators && opts.initialValidators.length > 0)
+    ) {
+      // We need to advance such that the committee is set up.
+      await cheatCodes.rollup.advanceToEpoch((await cheatCodes.rollup.getEpoch()) + BigInt(config.lagInEpochs + 1), {
+        updateDateProvider: dateProvider,
+      });
+      await cheatCodes.rollup.setupEpoch();
+      await cheatCodes.rollup.debugRollup();
     }
 
-    if (bbConfig?.cleanup) {
-      // remove the temp directory created for the acvm
-      logger.verbose(`Cleaning up BB state`);
-      await bbConfig.cleanup();
+    // Below we continue with what we described in the long comment on line 571.
+    let accountManagers: AccountManager[] = [];
+    if (numberOfAccounts === 0) {
+      logger.info('No accounts are being deployed, waiting for an empty block 1 to be mined');
+      while ((await pxe.getBlockNumber()) === 0) {
+        await sleep(2000);
+      }
+    } else {
+      logger.info(
+        `${numberOfAccounts} accounts are being deployed. Reliably progressing past genesis by setting minTxsPerBlock to 1 and waiting for the accounts to be deployed`,
+      );
+      accountManagers = await deployFundedSchnorrAccounts(pxe, initialFundedAccounts.slice(0, numberOfAccounts));
     }
 
-    await anvil?.stop().catch(err => getLogger().error(err));
-    await watcher.stop();
-    await blobSink?.stop();
+    // Now we restore the original minTxsPerBlock setting.
+    sequencerClient!.getSequencer().updateConfig({ minTxsPerBlock: originalMinTxsPerBlock });
 
-    if (directoryToCleanup) {
+    const wallets = await Promise.all(accountManagers.map(account => account.getWallet()));
+    if (initialFundedAccounts.length < numberOfAccounts) {
+      // TODO: Create (numberOfAccounts - initialFundedAccounts.length) wallets without funds.
+      throw new Error(
+        `Unable to deploy ${numberOfAccounts} accounts. Only ${initialFundedAccounts.length} accounts were funded.`,
+      );
+    }
+
+    const teardown = async () => {
       try {
-        logger.verbose(`Cleaning up data directory at ${directoryToCleanup}`);
-        await fs.rm(directoryToCleanup, { recursive: true, force: true, maxRetries: 3 });
+        await pxeTeardown();
+
+        await tryStop(aztecNode, logger);
+        await tryStop(proverNode, logger);
+
+        if (acvmConfig?.cleanup) {
+          await acvmConfig.cleanup();
+        }
+
+        if (bbConfig?.cleanup) {
+          await bbConfig.cleanup();
+        }
+
+        await tryStop(watcher, logger);
+        await tryStop(anvil, logger);
+
+        await tryStop(blobSink, logger);
+        await tryRmDir(directoryToCleanup, logger);
       } catch (err) {
-        logger.warn(`Failed to delete data directory at ${directoryToCleanup}: ${err}`);
+        logger.error(`Error during e2e test teardown`, err);
       }
-    }
-  };
+    };
 
-  return {
-    aztecNode,
-    blobSink,
-    cheatCodes,
-    config,
-    dateProvider,
-    deployL1ContractsValues,
-    initialFundedAccounts,
-    logger,
-    proverNode,
-    pxe,
-    sequencer,
-    teardown,
-    telemetryClient: telemetry,
-    wallet: wallets[0],
-    wallets,
-    watcher,
-  };
+    return {
+      aztecNode,
+      aztecNodeAdmin: aztecNode,
+      blobSink,
+      cheatCodes,
+      ethCheatCodes,
+      config,
+      dateProvider,
+      deployL1ContractsValues,
+      initialFundedAccounts,
+      logger,
+      mockGossipSubNetwork,
+      prefilledPublicData,
+      proverNode,
+      pxe,
+      sequencer: sequencerClient,
+      teardown,
+      telemetryClient: telemetry,
+      wallets,
+      wallet: wallets[0],
+      accounts: wallets.map(w => w.getAddress()),
+      watcher,
+    };
+  } catch (err) {
+    // TODO: Just hoisted anvil for now to ensure cleanup. Prob need to hoist the rest.
+    await anvil?.stop();
+    throw err;
+  }
 }
 
 /**
@@ -605,7 +761,7 @@ export async function setup(
  */
 
 // docs:start:public_deploy_accounts
-export async function ensureAccountsPubliclyDeployed(sender: Wallet, accountsToDeploy: Wallet[]) {
+export async function ensureAccountContractsPublished(sender: Wallet, accountsToDeploy: Wallet[]) {
   // We have to check whether the accounts are already deployed. This can happen if the test runs against
   // the sandbox and the test accounts exist
   const accountsAndAddresses = await Promise.all(
@@ -613,7 +769,7 @@ export async function ensureAccountsPubliclyDeployed(sender: Wallet, accountsToD
       const address = account.getAddress();
       return {
         address,
-        deployed: (await sender.getContractMetadata(address)).isContractPubliclyDeployed,
+        deployed: (await sender.getContractMetadata(address)).isContractPublished,
       };
     }),
   );
@@ -626,13 +782,13 @@ export async function ensureAccountsPubliclyDeployed(sender: Wallet, accountsToD
   ).map(contractMetadata => contractMetadata.contractInstance);
   const contractClass = await getContractClassFromArtifact(SchnorrAccountContractArtifact);
   if (!(await sender.getContractClassMetadata(contractClass.id, true)).isContractClassPubliclyRegistered) {
-    await (await registerContractClass(sender, SchnorrAccountContractArtifact)).send().wait();
+    await (await publishContractClass(sender, SchnorrAccountContractArtifact))
+      .send({ from: accountsToDeploy[0].getAddress() })
+      .wait();
   }
-  const requests = await Promise.all(
-    instances.map(async instance => (await deployInstance(sender, instance!)).request()),
-  );
-  const batch = new BatchCall(sender, [...requests]);
-  await batch.send().wait();
+  const requests = await Promise.all(instances.map(async instance => await publishInstance(sender, instance!)));
+  const batch = new BatchCall(sender, requests);
+  await batch.send({ from: accountsToDeploy[0].getAddress() }).wait();
 }
 // docs:end:public_deploy_accounts
 
@@ -672,11 +828,12 @@ export type BalancesFn = ReturnType<typeof getBalancesFn>;
 export function getBalancesFn(
   symbol: string,
   method: ContractMethod,
+  from: AztecAddress,
   logger: any,
 ): (...addresses: (AztecAddress | { address: AztecAddress })[]) => Promise<bigint[]> {
   const balances = async (...addressLikes: (AztecAddress | { address: AztecAddress })[]) => {
     const addresses = addressLikes.map(addressLike => ('address' in addressLike ? addressLike.address : addressLike));
-    const b = await Promise.all(addresses.map(address => method(address).simulate()));
+    const b = await Promise.all(addresses.map(address => method(address).simulate({ from })));
     const debugString = `${symbol} balances: ${addresses.map((address, i) => `${address}: ${b[i]}`).join(', ')}`;
     logger.verbose(debugString);
     return b;
@@ -712,24 +869,47 @@ export async function expectMappingDelta<K, V extends number | bigint>(
 }
 
 /**
- * Deploy the protocol contracts to a running instance.
+ * Computes the address of the "canonical" SponosoredFPCContract. This is not a protocol contract
+ * but by conventions its address is computed with a salt of 0.
+ * @returns The address of the sponsored FPC contract
  */
-export async function setupCanonicalFeeJuice(pxe: PXE) {
-  // "deploy" the Fee Juice as it contains public functions
-  const feeJuicePortalAddress = (await pxe.getNodeInfo()).l1ContractAddresses.feeJuicePortalAddress;
-  const wallet = new SignerlessWallet(pxe);
-  const feeJuice = await FeeJuiceContract.at(ProtocolContractAddress.FeeJuice, wallet);
+export function getSponsoredFPCInstance(): Promise<ContractInstanceWithAddress> {
+  return Promise.resolve(
+    getContractInstanceFromInstantiationParams(SponsoredFPCContract.artifact, {
+      salt: new Fr(SPONSORED_FPC_SALT),
+    }),
+  );
+}
 
-  try {
-    const paymentMethod = new FeeJuicePaymentMethod(ProtocolContractAddress.FeeJuice);
-    await feeJuice.methods
-      .initialize(feeJuicePortalAddress, FEE_JUICE_INITIAL_MINT)
-      .send({ fee: { paymentMethod, gasSettings: { teardownGasLimits: Gas.empty() } } })
-      .wait();
-    getLogger().info(`Fee Juice successfully setup. Portal address: ${feeJuicePortalAddress}`);
-  } catch (error) {
-    getLogger().warn(`Fee Juice might have already been setup. Got error: ${inspect(error)}.`);
-  }
+/**
+ * Computes the address of the "canonical" SponosoredFPCContract. This is not a protocol contract
+ * but by conventions its address is computed with a salt of 0.
+ * @returns The address of the sponsored FPC contract
+ */
+export async function getSponsoredFPCAddress() {
+  const sponsoredFPCInstance = await getSponsoredFPCInstance();
+  return sponsoredFPCInstance.address;
+}
+
+/**
+ * Deploy a sponsored FPC contract to a running instance.
+ */
+export async function setupSponsoredFPC(pxe: PXE) {
+  const instance = await getContractInstanceFromInstantiationParams(SponsoredFPCContract.artifact, {
+    salt: new Fr(SPONSORED_FPC_SALT),
+  });
+
+  await pxe.registerContract({ instance, artifact: SponsoredFPCContract.artifact });
+  getLogger().info(`SponsoredFPC: ${instance.address}`);
+  return instance;
+}
+
+/**
+ * Registers the SponsoredFPC in this PXE instance
+ * @param pxe - The pxe client
+ */
+export async function registerSponsoredFPC(pxe: PXE): Promise<void> {
+  await pxe.registerContract({ instance: await getSponsoredFPCInstance(), artifact: SponsoredFPCContract.artifact });
 }
 
 export async function waitForProvenChain(node: AztecNode, targetBlock?: number, timeoutSec = 60, intervalSec = 1) {
@@ -743,81 +923,79 @@ export async function waitForProvenChain(node: AztecNode, targetBlock?: number,
   );
 }
 
-export async function createAndSyncProverNode(
+export function createAndSyncProverNode(
   proverNodePrivateKey: `0x${string}`,
   aztecNodeConfig: AztecNodeConfig,
-  aztecNode: AztecNode,
-  dataDirectory: string,
+  proverNodeConfig: Partial<ProverNodeConfig> & Pick<DataStoreConfig, 'dataDirectory'> & { dontStart?: boolean },
+  aztecNode: AztecNode | undefined,
   prefilledPublicData: PublicDataTreeLeaf[] = [],
+  proverNodeDeps: ProverNodeDeps = {},
 ) {
-  // 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(),
-  };
+  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 = aztecNode && {
+      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: proverNodeConfig.dataDirectory };
+    const archiver = await createArchiver(archiverConfig, { blobSinkClient }, { blockUntilSync: true });
+
+    // Prover node config is for simulated proofs
+    const proverConfig: ProverNodeConfig = {
+      ...aztecNodeConfig,
+      txCollectionNodeRpcUrls: [],
+      realProofs: false,
+      proverAgentCount: 2,
+      publisherPrivateKeys: [new SecretValue(proverNodePrivateKey)],
+      proverNodeMaxPendingJobs: 10,
+      proverNodeMaxParallelBlocksPerEpoch: 32,
+      proverNodePollingIntervalMs: 200,
+      txGatheringIntervalMs: 1000,
+      txGatheringBatchSize: 10,
+      txGatheringMaxParallelRequestsPerNode: 10,
+      txGatheringTimeoutMs: 24_000,
+      proverNodeFailedEpochStore: undefined,
+      proverId: EthAddress.fromNumber(1),
+      proverNodeEpochProvingDelayMs: undefined,
+      ...proverNodeConfig,
+    };
+
+    const l1TxUtils = createDelayedL1TxUtils(
+      aztecNodeConfig,
+      proverNodePrivateKey,
+      'prover-node',
+      proverNodeDeps.dateProvider,
+    );
 
-  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,
+    const proverNode = await createProverNode(
+      proverConfig,
+      { ...proverNodeDeps, aztecNodeTxProvider, archiver: archiver as Archiver, l1TxUtils },
+      { prefilledPublicData },
+    );
+    getLogger().info(`Created and synced prover node`, { publisherAddress: l1TxUtils.client.account!.address });
+    if (!proverNodeConfig.dontStart) {
+      await proverNode.start();
+    }
+    return proverNode;
   });
-
-  // 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 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;
 }
 
-function createDelayedL1TxUtils(aztecNodeConfig: AztecNodeConfig, privateKey: `0x${string}`, logName: string) {
-  const { publicClient, walletClient } = createL1Clients(aztecNodeConfig.l1RpcUrls, privateKey, foundry);
+function createDelayedL1TxUtils(
+  aztecNodeConfig: AztecNodeConfig,
+  privateKey: `0x${string}`,
+  logName: string,
+  dateProvider?: DateProvider,
+) {
+  const l1Client = createExtendedL1Client(aztecNodeConfig.l1RpcUrls, privateKey, foundry);
 
   const log = createLogger(logName);
-  const l1TxUtils = new DelayedTxUtils(publicClient, walletClient, log, aztecNodeConfig);
+  const l1TxUtils = createDelayedL1TxUtilsFromViemWallet(l1Client, log, dateProvider, aztecNodeConfig);
   l1TxUtils.enableDelayer(aztecNodeConfig.ethereumSlotDuration);
   return l1TxUtils;
 }
-
-export async function createForwarderContract(
-  aztecNodeConfig: AztecNodeConfig,
-  privateKey: `0x${string}`,
-  rollupAddress: Hex,
-) {
-  const { walletClient, publicClient } = createL1Clients(aztecNodeConfig.l1RpcUrls, privateKey, foundry);
-  const forwarderContract = await ForwarderContract.create(
-    walletClient.account.address,
-    walletClient,
-    publicClient,
-    createLogger('forwarder'),
-    rollupAddress,
-  );
-  return forwarderContract;
-}