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

package/src/fixtures/setup_p2p_test.ts

@@ -3,8 +3,11 @@
  */
 import { type AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
 import type { SentTx } from '@aztec/aztec.js';
+import { SecretValue } from '@aztec/foundation/config';
 import { addLogNameHandler, removeLogNameHandler } from '@aztec/foundation/log';
+import { bufferToHex } from '@aztec/foundation/string';
 import type { DateProvider } from '@aztec/foundation/timer';
+import type { ProverNodeConfig, ProverNodeDeps } from '@aztec/prover-node';
 import type { PXEService } from '@aztec/pxe/server';
 import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
 
@@ -12,13 +15,13 @@ import getPort from 'get-port';
 import { AsyncLocalStorage } from 'node:async_hooks';
 
 import { TEST_PEER_CHECK_INTERVAL_MS } from './fixtures.js';
-import { getPrivateKeyFromIndex } from './utils.js';
+import { createAndSyncProverNode, getPrivateKeyFromIndex } from './utils.js';
 import { getEndToEndTestTelemetryClient } from './with_telemetry_utils.js';
 
-// Setup snapshots will create a node with index 0, so all of our loops here
-// need to start from 1 to avoid running validators with the same key
-export const PROPOSER_PRIVATE_KEYS_START_INDEX = 1;
-export const ATTESTER_PRIVATE_KEYS_START_INDEX = 1001;
+// Setup snapshots will create a node with index 0, and run extra bootstrap with
+// index 1, and prover node with index 2, so all of our loops here need to start from 3
+// to avoid running validators with the same key
+export const ATTESTER_PRIVATE_KEYS_START_INDEX = 3;
 
 export interface NodeContext {
   node: AztecNodeService;
@@ -36,7 +39,7 @@ export function generatePrivateKeys(startIndex: number, numberOfKeys: number): `
 }
 
 export async function createNodes(
-  config: AztecNodeConfig,
+  config: AztecNodeConfig & { dontStartSequencer?: boolean },
   dateProvider: DateProvider,
   bootstrapNodeEnr: string,
   numNodes: number,
@@ -44,6 +47,7 @@ export async function createNodes(
   prefilledPublicData?: PublicDataTreeLeaf[],
   dataDirectory?: string,
   metricsPort?: number,
+  indexOffset = 0,
 ): Promise<AztecNodeService[]> {
   const nodePromises: Promise<AztecNodeService>[] = [];
   const loggerIdStorage = new AsyncLocalStorage<string>();
@@ -52,16 +56,17 @@ export async function createNodes(
   addLogNameHandler(logNameHandler);
 
   for (let i = 0; i < numNodes; i++) {
+    const index = indexOffset + i;
     // We run on ports from the bootnode upwards
-    const port = bootNodePort + i + 1;
+    const port = bootNodePort + 1 + index;
 
-    const dataDir = dataDirectory ? `${dataDirectory}-${i}` : undefined;
+    const dataDir = dataDirectory ? `${dataDirectory}-${index}` : undefined;
     const nodePromise = createNode(
       config,
       dateProvider,
       port,
       bootstrapNodeEnr,
-      i,
+      index,
       prefilledPublicData,
       dataDir,
       metricsPort,
@@ -70,55 +75,113 @@ export async function createNodes(
     nodePromises.push(nodePromise);
   }
   const nodes = await Promise.all(nodePromises);
+
+  // Sanity check that we have a sequencer if required
+  const seqClient = nodes[0].getSequencer();
+  if (!seqClient && config.disableValidator === false) {
+    throw new Error('Sequencer not found');
+  }
+
   removeLogNameHandler(logNameHandler);
   return nodes;
 }
 
-// creates a P2P enabled instance of Aztec Node Service
+/** Creates a P2P enabled instance of Aztec Node Service with a validator */
 export async function createNode(
-  config: AztecNodeConfig,
+  config: AztecNodeConfig & { dontStartSequencer?: boolean },
   dateProvider: DateProvider,
   tcpPort: number,
   bootstrapNode: string | undefined,
-  accountIndex: number,
+  addressIndex: number,
   prefilledPublicData?: PublicDataTreeLeaf[],
   dataDirectory?: string,
   metricsPort?: number,
   loggerIdStorage?: AsyncLocalStorage<string>,
 ) {
   const createNode = async () => {
-    const validatorConfig = await createValidatorConfig(config, bootstrapNode, tcpPort, accountIndex, dataDirectory);
+    const validatorConfig = await createValidatorConfig(config, bootstrapNode, tcpPort, addressIndex, dataDirectory);
     const telemetry = getEndToEndTestTelemetryClient(metricsPort);
-    return await AztecNodeService.createAndSync(validatorConfig, { telemetry, dateProvider }, { prefilledPublicData });
+    return await AztecNodeService.createAndSync(
+      validatorConfig,
+      { telemetry, dateProvider },
+      { prefilledPublicData, dontStartSequencer: config.dontStartSequencer },
+    );
   };
   return loggerIdStorage ? await loggerIdStorage.run(tcpPort.toString(), createNode) : createNode();
 }
 
-export async function createValidatorConfig(
+/** Creates a P2P enabled instance of Aztec Node Service without a validator */
+export async function createNonValidatorNode(
+  baseConfig: AztecNodeConfig,
+  dateProvider: DateProvider,
+  tcpPort: number,
+  bootstrapNode: string | undefined,
+  prefilledPublicData?: PublicDataTreeLeaf[],
+  dataDirectory?: string,
+  metricsPort?: number,
+  loggerIdStorage?: AsyncLocalStorage<string>,
+) {
+  const createNode = async () => {
+    const p2pConfig = await createP2PConfig(baseConfig, bootstrapNode, tcpPort, dataDirectory);
+    const config: AztecNodeConfig = {
+      ...p2pConfig,
+      disableValidator: true,
+      validatorPrivateKeys: undefined,
+      publisherPrivateKeys: [],
+    };
+    const telemetry = getEndToEndTestTelemetryClient(metricsPort);
+    return await AztecNodeService.createAndSync(config, { telemetry, dateProvider }, { prefilledPublicData });
+  };
+  return loggerIdStorage ? await loggerIdStorage.run(tcpPort.toString(), createNode) : createNode();
+}
+
+export async function createProverNode(
+  config: AztecNodeConfig,
+  tcpPort: number,
+  bootstrapNode: string | undefined,
+  addressIndex: number,
+  proverNodeDeps: ProverNodeDeps & Required<Pick<ProverNodeDeps, 'dateProvider'>>,
+  prefilledPublicData?: PublicDataTreeLeaf[],
+  dataDirectory?: string,
+  metricsPort?: number,
+  loggerIdStorage?: AsyncLocalStorage<string>,
+) {
+  const createProverNode = async () => {
+    const proverNodePrivateKey = getPrivateKeyFromIndex(ATTESTER_PRIVATE_KEYS_START_INDEX + addressIndex)!;
+    const telemetry = getEndToEndTestTelemetryClient(metricsPort);
+
+    const proverConfig: Partial<ProverNodeConfig> = await createP2PConfig(
+      config,
+      bootstrapNode,
+      tcpPort,
+      dataDirectory,
+    );
+
+    const aztecNodeRpcTxProvider = undefined;
+    return await createAndSyncProverNode(
+      bufferToHex(proverNodePrivateKey),
+      config,
+      { ...proverConfig, dataDirectory },
+      aztecNodeRpcTxProvider,
+      prefilledPublicData,
+      { ...proverNodeDeps, telemetry },
+    );
+  };
+  return loggerIdStorage ? await loggerIdStorage.run(tcpPort.toString(), createProverNode) : createProverNode();
+}
+
+export async function createP2PConfig(
   config: AztecNodeConfig,
   bootstrapNodeEnr?: string,
   port?: number,
-  accountIndex: number = 1,
   dataDirectory?: string,
 ) {
   port = port ?? (await getPort());
 
-  const attesterPrivateKey: `0x${string}` = `0x${getPrivateKeyFromIndex(
-    ATTESTER_PRIVATE_KEYS_START_INDEX + accountIndex,
-  )!.toString('hex')}`;
-  const proposerPrivateKey: `0x${string}` = `0x${getPrivateKeyFromIndex(
-    PROPOSER_PRIVATE_KEYS_START_INDEX + accountIndex,
-  )!.toString('hex')}`;
-
-  config.validatorPrivateKey = attesterPrivateKey;
-  config.publisherPrivateKey = proposerPrivateKey;
-
   const nodeConfig: AztecNodeConfig = {
     ...config,
-    udpListenAddress: `0.0.0.0:${port}`,
-    tcpListenAddress: `0.0.0.0:${port}`,
-    tcpAnnounceAddress: `127.0.0.1:${port}`,
-    udpAnnounceAddress: `127.0.0.1:${port}`,
+    p2pIp: `127.0.0.1`,
+    p2pPort: port,
     p2pEnabled: true,
     peerCheckIntervalMS: TEST_PEER_CHECK_INTERVAL_MS,
     blockCheckIntervalMS: 1000,
@@ -128,3 +191,22 @@ export async function createValidatorConfig(
 
   return nodeConfig;
 }
+
+export async function createValidatorConfig(
+  config: AztecNodeConfig,
+  bootstrapNodeEnr?: string,
+  port?: number,
+  addressIndex: number = 1,
+  dataDirectory?: string,
+) {
+  const attesterPrivateKey = bufferToHex(getPrivateKeyFromIndex(ATTESTER_PRIVATE_KEYS_START_INDEX + addressIndex)!);
+  const p2pConfig = await createP2PConfig(config, bootstrapNodeEnr, port, dataDirectory);
+  const nodeConfig: AztecNodeConfig = {
+    ...config,
+    ...p2pConfig,
+    validatorPrivateKeys: new SecretValue([attesterPrivateKey]),
+    publisherPrivateKeys: [new SecretValue(attesterPrivateKey)],
+  };
+
+  return nodeConfig;
+}

package/src/fixtures/snapshot_manager.ts

@@ -2,31 +2,41 @@ import { SchnorrAccountContractArtifact } from '@aztec/accounts/schnorr';
 import { type InitialAccountData, deployFundedSchnorrAccounts, generateSchnorrAccounts } from '@aztec/accounts/testing';
 import { type AztecNodeConfig, AztecNodeService, getConfigEnvVars } from '@aztec/aztec-node';
 import {
-  AnvilTestWatcher,
   type AztecAddress,
+  type AztecNode,
   BatchCall,
-  type Capsule,
-  CheatCodes,
   type CompleteAddress,
   type ContractFunctionInteraction,
-  type DeployL1ContractsReturnType,
-  type FunctionCall,
+  DefaultWaitForProvenOpts,
+  EthAddress,
   type Logger,
   type PXE,
   type Wallet,
   getContractClassFromArtifact,
+  waitForProven,
 } from '@aztec/aztec.js';
-import { deployInstance, registerContractClass } from '@aztec/aztec.js/deployment';
+import { publishContractClass, publishInstance } from '@aztec/aztec.js/deployment';
+import { AnvilTestWatcher, CheatCodes } from '@aztec/aztec/testing';
 import { type BlobSinkServer, createBlobSinkServer } from '@aztec/blob-sink/server';
-import { type DeployL1ContractsArgs, createL1Clients, getL1ContractsConfigEnvVars, l1Artifacts } from '@aztec/ethereum';
+import {
+  type DeployL1ContractsArgs,
+  type DeployL1ContractsReturnType,
+  createExtendedL1Client,
+  deployMulticall3,
+  getL1ContractsConfigEnvVars,
+} from '@aztec/ethereum';
 import { EthCheatCodesWithState, startAnvil } from '@aztec/ethereum/test';
 import { asyncMap } from '@aztec/foundation/async-map';
+import { SecretValue } from '@aztec/foundation/config';
 import { randomBytes } from '@aztec/foundation/crypto';
+import { tryRmDir } from '@aztec/foundation/fs';
 import { createLogger } from '@aztec/foundation/log';
 import { resolver, reviver } from '@aztec/foundation/serialize';
 import { TestDateProvider } from '@aztec/foundation/timer';
 import type { ProverNode } from '@aztec/prover-node';
 import { type PXEService, createPXEService, getPXEServiceConfig } from '@aztec/pxe/server';
+import type { SequencerClient } from '@aztec/sequencer-client';
+import { tryStop } from '@aztec/stdlib/interfaces/server';
 import { getConfigEnvVars as getTelemetryConfig, initTelemetryClient } from '@aztec/telemetry-client';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
@@ -37,14 +47,21 @@ import fs from 'fs/promises';
 import getPort from 'get-port';
 import { tmpdir } from 'os';
 import path, { join } from 'path';
-import { type Hex, getContract } from 'viem';
+import type { Hex } from 'viem';
 import { mnemonicToAccount } from 'viem/accounts';
+import { foundry } from 'viem/chains';
 
-import { MNEMONIC, TEST_PEER_CHECK_INTERVAL_MS } from './fixtures.js';
+import { MNEMONIC, TEST_MAX_TX_POOL_SIZE, TEST_PEER_CHECK_INTERVAL_MS } from './fixtures.js';
 import { getACVMConfig } from './get_acvm_config.js';
 import { getBBConfig } from './get_bb_config.js';
 import { setupL1Contracts } from './setup_l1_contracts.js';
-import { type SetupOptions, createAndSyncProverNode, getLogger, getPrivateKeyFromIndex } from './utils.js';
+import {
+  type SetupOptions,
+  createAndSyncProverNode,
+  getLogger,
+  getPrivateKeyFromIndex,
+  getSponsoredFPCAddress,
+} from './utils.js';
 import { getEndToEndTestTelemetryClient } from './with_telemetry_utils.js';
 
 export type SubsystemsContext = {
@@ -58,6 +75,7 @@ export type SubsystemsContext = {
   proverNode?: ProverNode;
   watcher: AnvilTestWatcher;
   cheatCodes: CheatCodes;
+  sequencer: SequencerClient;
   dateProvider: TestDateProvider;
   blobSink: BlobSinkServer;
   initialFundedAccounts: InitialAccountData[];
@@ -253,24 +271,19 @@ async function teardown(context: SubsystemsContext | undefined) {
   if (!context) {
     return;
   }
+  const logger = getLogger();
   try {
-    getLogger().info('Tearing down subsystems');
-    await context.proverNode?.stop();
-    await context.aztecNode.stop();
+    logger.info('Tearing down subsystems');
+    await tryStop(context.proverNode);
+    await tryStop(context.aztecNode);
     await context.acvmConfig?.cleanup();
     await context.bbConfig?.cleanup();
-    await context.anvil.stop();
-    await context.watcher.stop();
-    await context.blobSink.stop();
-    if (context.directoryToCleanup) {
-      try {
-        await fs.rm(context.directoryToCleanup, { recursive: true, force: true, maxRetries: 3 });
-      } catch (err) {
-        getLogger().warn(`Failed to delete tmp directory ${context.directoryToCleanup}: ${err}`);
-      }
-    }
+    await tryStop(context.anvil);
+    await tryStop(context.watcher);
+    await tryStop(context.blobSink);
+    await tryRmDir(context.directoryToCleanup, logger);
   } catch (err) {
-    getLogger().error('Error during teardown', err);
+    logger.error('Error during teardown', err);
   }
 }
 
@@ -291,10 +304,24 @@ async function setupFromFresh(
 
   const blobSinkPort = await getPort();
 
+  // Default to no slashing
+  opts.slasherFlavor ??= 'none';
+  deployL1ContractsArgs.slasherFlavor ??= opts.slasherFlavor;
+
   // Fetch the AztecNode config.
   // TODO: For some reason this is currently the union of a bunch of subsystems. That needs fixing.
   const aztecNodeConfig: AztecNodeConfig & SetupOptions = { ...getConfigEnvVars(), ...opts };
   aztecNodeConfig.peerCheckIntervalMS = TEST_PEER_CHECK_INTERVAL_MS;
+  aztecNodeConfig.maxTxPoolSize = opts.maxTxPoolSize ?? TEST_MAX_TX_POOL_SIZE;
+  // Only enable proving if specifically requested.
+  aztecNodeConfig.realProofs = !!opts.realProofs;
+  // Only enforce the time table if requested
+  aztecNodeConfig.enforceTimeTable = !!opts.enforceTimeTable;
+  // Only set the target committee size if it is explicitly set
+  aztecNodeConfig.aztecTargetCommitteeSize = opts.aztecTargetCommitteeSize ?? 0;
+  aztecNodeConfig.listenAddress = '127.0.0.1';
+
+  deployL1ContractsArgs.aztecTargetCommitteeSize ??= aztecNodeConfig.aztecTargetCommitteeSize;
 
   // Create a temp directory for all ephemeral state and cleanup afterwards
   const directoryToCleanup = path.join(tmpdir(), randomBytes(8).toString('hex'));
@@ -304,86 +331,63 @@ async function setupFromFresh(
   } else {
     aztecNodeConfig.dataDirectory = statePath;
   }
-  aztecNodeConfig.blobSinkUrl = `http://localhost:${blobSinkPort}`;
-
-  // Setup blob sink service
-  const blobSink = await createBlobSinkServer({
-    port: blobSinkPort,
-    dataStoreConfig: {
-      dataDirectory: aztecNodeConfig.dataDirectory,
-      dataStoreMapSizeKB: aztecNodeConfig.dataStoreMapSizeKB,
-    },
-  });
-  await blobSink.start();
-
-  // Start anvil. We go via a wrapper script to ensure if the parent dies, anvil dies.
-  logger.verbose('Starting anvil...');
-  const res = await startAnvil({ l1BlockTime: opts.ethereumSlotDuration });
-  const anvil = res.anvil;
-  aztecNodeConfig.l1RpcUrls = [res.rpcUrl];
+  aztecNodeConfig.blobSinkUrl = `http://127.0.0.1:${blobSinkPort}`;
 
-  // Deploy our L1 contracts.
-  logger.verbose('Deploying L1 contracts...');
-  const hdAccount = mnemonicToAccount(MNEMONIC, { accountIndex: 0 });
+  const hdAccount = mnemonicToAccount(MNEMONIC, { addressIndex: 0 });
   const publisherPrivKeyRaw = hdAccount.getHdKey().privateKey;
   const publisherPrivKey = publisherPrivKeyRaw === null ? null : Buffer.from(publisherPrivKeyRaw);
 
+  const l1Client = createExtendedL1Client([aztecNodeConfig.l1RpcUrls[0]], hdAccount, foundry);
+
   const validatorPrivKey = getPrivateKeyFromIndex(0);
   const proverNodePrivateKey = getPrivateKeyFromIndex(0);
 
-  aztecNodeConfig.publisherPrivateKey = `0x${publisherPrivKey!.toString('hex')}`;
-  aztecNodeConfig.validatorPrivateKey = `0x${validatorPrivKey!.toString('hex')}`;
+  aztecNodeConfig.publisherPrivateKeys = [new SecretValue<`0x${string}`>(`0x${publisherPrivKey!.toString('hex')}`)];
+  aztecNodeConfig.validatorPrivateKeys = new SecretValue([`0x${validatorPrivKey!.toString('hex')}`]);
+  aztecNodeConfig.coinbase = opts.coinbase ?? EthAddress.fromString(`${hdAccount.address}`);
 
+  logger.info(`Setting up environment with config`, aztecNodeConfig);
+
+  // Start anvil. We go via a wrapper script to ensure if the parent dies, anvil dies.
+  logger.verbose('Starting anvil...');
+  const res = await startAnvil({ l1BlockTime: opts.ethereumSlotDuration });
+  const anvil = res.anvil;
+  aztecNodeConfig.l1RpcUrls = [res.rpcUrl];
   const ethCheatCodes = new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls);
 
+  // Deploy our L1 contracts.
+  logger.verbose('Deploying L1 contracts...');
   if (opts.l1StartTime) {
-    await ethCheatCodes.warp(opts.l1StartTime);
+    await ethCheatCodes.warp(opts.l1StartTime, { resetBlockInterval: true });
   }
 
   const initialFundedAccounts = await generateSchnorrAccounts(numberOfInitialFundedAccounts);
-  const { genesisArchiveRoot, genesisBlockHash, prefilledPublicData } = await getGenesisValues(
-    initialFundedAccounts.map(a => a.address),
+  const sponsoredFPCAddress = await getSponsoredFPCAddress();
+  const { genesisArchiveRoot, prefilledPublicData, fundingNeeded } = await getGenesisValues(
+    initialFundedAccounts.map(a => a.address).concat(sponsoredFPCAddress),
     opts.initialAccountFeeJuice,
   );
 
+  await deployMulticall3(l1Client, logger);
+
   const deployL1ContractsValues = await setupL1Contracts(aztecNodeConfig.l1RpcUrls[0], hdAccount, logger, {
     ...getL1ContractsConfigEnvVars(),
     genesisArchiveRoot,
-    genesisBlockHash,
+    feeJuicePortalInitialBalance: fundingNeeded,
     salt: opts.salt,
     ...deployL1ContractsArgs,
     initialValidators: opts.initialValidators,
   });
   aztecNodeConfig.l1Contracts = deployL1ContractsValues.l1ContractAddresses;
-  aztecNodeConfig.l1PublishRetryIntervalMS = 100;
-
-  if (opts.fundRewardDistributor) {
-    // Mints block rewards for 10000 blocks to the rewardDistributor contract
+  aztecNodeConfig.rollupVersion = deployL1ContractsValues.rollupVersion;
 
-    const rewardDistributor = getContract({
-      address: deployL1ContractsValues.l1ContractAddresses.rewardDistributorAddress.toString(),
-      abi: l1Artifacts.rewardDistributor.contractAbi,
-      client: deployL1ContractsValues.publicClient,
-    });
-
-    const blockReward = await rewardDistributor.read.BLOCK_REWARD();
-    const mintAmount = 10_000n * (blockReward as bigint);
-
-    const feeJuice = getContract({
-      address: deployL1ContractsValues.l1ContractAddresses.feeJuiceAddress.toString(),
-      abi: l1Artifacts.feeAsset.contractAbi,
-      client: deployL1ContractsValues.walletClient,
-    });
-
-    const rewardDistributorMintTxHash = await feeJuice.write.mint([rewardDistributor.address, mintAmount], {} as any);
-    await deployL1ContractsValues.publicClient.waitForTransactionReceipt({ hash: rewardDistributorMintTxHash });
-    logger.info(`Funding rewardDistributor in ${rewardDistributorMintTxHash}`);
-  }
+  const dateProvider = new TestDateProvider();
 
   const watcher = new AnvilTestWatcher(
     new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls),
     deployL1ContractsValues.l1ContractAddresses.rollupAddress,
-    deployL1ContractsValues.publicClient,
+    deployL1ContractsValues.l1Client,
+    dateProvider,
   );
   await watcher.start();
 
@@ -401,8 +405,21 @@ async function setupFromFresh(
 
   const telemetry = getEndToEndTestTelemetryClient(opts.metricsPort);
 
-  logger.verbose('Creating and synching an aztec node...');
-  const dateProvider = new TestDateProvider();
+  // Setup blob sink service
+  const blobSink = await createBlobSinkServer(
+    {
+      l1ChainId: aztecNodeConfig.l1ChainId,
+      l1RpcUrls: aztecNodeConfig.l1RpcUrls,
+      l1Contracts: aztecNodeConfig.l1Contracts,
+      port: blobSinkPort,
+      dataDirectory: aztecNodeConfig.dataDirectory,
+      dataStoreMapSizeKb: aztecNodeConfig.dataStoreMapSizeKb,
+    },
+    telemetry,
+  );
+  await blobSink.start();
+
+  logger.info('Creating and synching an aztec node...');
   const aztecNode = await AztecNodeService.createAndSync(
     aztecNodeConfig,
     { telemetry, dateProvider },
@@ -411,12 +428,16 @@ async function setupFromFresh(
 
   let proverNode: ProverNode | undefined = undefined;
   if (opts.startProverNode) {
-    logger.verbose('Creating and syncing a simulated prover node...');
+    logger.verbose('Creating and syncing a simulated prover node with p2p disabled...');
     proverNode = await createAndSyncProverNode(
       `0x${proverNodePrivateKey!.toString('hex')}`,
       aztecNodeConfig,
+      {
+        ...aztecNodeConfig.proverNodeConfig,
+        dataDirectory: path.join(directoryToCleanup, randomBytes(8).toString('hex')),
+        p2pEnabled: false,
+      },
       aztecNode,
-      path.join(directoryToCleanup, randomBytes(8).toString('hex')),
       prefilledPublicData,
     );
   }
@@ -424,6 +445,8 @@ async function setupFromFresh(
   logger.verbose('Creating pxe...');
   const pxeConfig = getPXEServiceConfig();
   pxeConfig.dataDirectory = statePath ?? path.join(directoryToCleanup, randomBytes(8).toString('hex'));
+  // Only enable proving if specifically requested.
+  pxeConfig.proverEnabled = !!opts.realProofs;
   const pxe = await createPXEService(aztecNode, pxeConfig);
 
   const cheatCodes = await CheatCodes.create(aztecNodeConfig.l1RpcUrls, pxe);
@@ -438,6 +461,7 @@ async function setupFromFresh(
     anvil,
     aztecNode,
     pxe,
+    sequencer: aztecNode.getSequencer()!,
     acvmConfig,
     bbConfig,
     deployL1ContractsValues,
@@ -470,20 +494,12 @@ async function setupFromState(statePath: string, logger: Logger): Promise<Subsys
   );
   aztecNodeConfig.dataDirectory = statePath;
   aztecNodeConfig.blobSinkUrl = `http://127.0.0.1:${blobSinkPort}`;
+  aztecNodeConfig.listenAddress = '127.0.0.1';
 
   const initialFundedAccounts: InitialAccountData[] =
     JSON.parse(readFileSync(`${statePath}/accounts.json`, 'utf-8'), reviver) || [];
   const { prefilledPublicData } = await getGenesisValues(initialFundedAccounts.map(a => a.address));
 
-  const blobSink = await createBlobSinkServer({
-    port: blobSinkPort,
-    dataStoreConfig: {
-      dataDirectory: statePath,
-      dataStoreMapSizeKB: aztecNodeConfig.dataStoreMapSizeKB,
-    },
-  });
-  await blobSink.start();
-
   // Start anvil. We go via a wrapper script to ensure if the parent dies, anvil dies.
   const { anvil, rpcUrl } = await startAnvil();
   aztecNodeConfig.l1RpcUrls = [rpcUrl];
@@ -506,18 +522,32 @@ 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 dateProvider = new TestDateProvider();
   const watcher = new AnvilTestWatcher(
     new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls),
     aztecNodeConfig.l1Contracts.rollupAddress,
-    publicClient,
+    l1Client,
+    dateProvider,
   );
   await watcher.start();
 
-  logger.verbose('Creating aztec node...');
   const telemetry = initTelemetryClient(getTelemetryConfig());
-  const dateProvider = new TestDateProvider();
+  const blobSink = await createBlobSinkServer(
+    {
+      l1ChainId: aztecNodeConfig.l1ChainId,
+      l1RpcUrls: aztecNodeConfig.l1RpcUrls,
+      l1Contracts: aztecNodeConfig.l1Contracts,
+      port: blobSinkPort,
+      dataDirectory: statePath,
+      dataStoreMapSizeKb: aztecNodeConfig.dataStoreMapSizeKb,
+    },
+    telemetry,
+  );
+  await blobSink.start();
+
+  logger.verbose('Creating aztec node...');
   const aztecNode = await AztecNodeService.createAndSync(
     aztecNodeConfig,
     { telemetry, dateProvider },
@@ -532,8 +562,12 @@ async function setupFromState(statePath: string, logger: Logger): Promise<Subsys
     proverNode = await createAndSyncProverNode(
       proverNodePrivateKeyHex,
       aztecNodeConfig,
+      {
+        ...aztecNodeConfig.proverNodeConfig,
+        dataDirectory: path.join(directoryToCleanup, randomBytes(8).toString('hex')),
+        p2pEnabled: false,
+      },
       aztecNode,
-      path.join(directoryToCleanup, randomBytes(8).toString('hex')),
       prefilledPublicData,
     );
   }
@@ -550,13 +584,14 @@ async function setupFromState(statePath: string, logger: Logger): Promise<Subsys
     anvil,
     aztecNode,
     pxe,
+    sequencer: aztecNode.getSequencer()!,
     acvmConfig,
     bbConfig,
     proverNode,
     deployL1ContractsValues: {
-      walletClient,
-      publicClient,
+      l1Client,
       l1ContractAddresses: aztecNodeConfig.l1Contracts,
+      rollupVersion: aztecNodeConfig.rollupVersion,
     },
     watcher,
     cheatCodes,
@@ -580,7 +615,12 @@ export const deployAccounts =
 
     logger.verbose('Deploying accounts funded with fee juice...');
     const deployedAccounts = initialFundedAccounts.slice(0, numberOfAccounts);
-    await deployFundedSchnorrAccounts(pxe, deployedAccounts, { proven: waitUntilProven });
+    await deployFundedSchnorrAccounts(
+      pxe,
+      deployedAccounts,
+      undefined,
+      waitUntilProven ? DefaultWaitForProvenOpts : undefined,
+    );
 
     return { deployedAccounts };
   };
@@ -590,11 +630,14 @@ export const deployAccounts =
  * Use this when you need to make a public call to an account contract, such as for requesting a public authwit.
  * @param sender - Wallet to send the deployment tx.
  * @param accountsToDeploy - Which accounts to publicly deploy.
+ * @param waitUntilProven - Whether to wait for the tx to be proven.
+ * @param pxeOrNode - PXE or AztecNode to wait for proven.
  */
 export async function publicDeployAccounts(
   sender: Wallet,
   accountsToDeploy: (CompleteAddress | AztecAddress)[],
   waitUntilProven = false,
+  pxeOrNode?: PXE | AztecNode,
 ) {
   const accountAddressesToDeploy = accountsToDeploy.map(a => ('address' in a ? a.address : a));
   const instances = (
@@ -604,14 +647,19 @@ export async function publicDeployAccounts(
   const contractClass = await getContractClassFromArtifact(SchnorrAccountContractArtifact);
   const alreadyRegistered = (await sender.getContractClassMetadata(contractClass.id)).isContractClassPubliclyRegistered;
 
-  const fns: ContractFunctionInteraction[] = await Promise.all([
-    ...(!alreadyRegistered ? [registerContractClass(sender, SchnorrAccountContractArtifact)] : []),
-    ...instances.map(instance => deployInstance(sender, instance!)),
+  const calls: ContractFunctionInteraction[] = await Promise.all([
+    ...(!alreadyRegistered ? [publishContractClass(sender, SchnorrAccountContractArtifact)] : []),
+    ...instances.map(instance => publishInstance(sender, instance!)),
   ]);
-  const calls: FunctionCall[] = await Promise.all(fns.map(fn => fn.request()));
-  const capsules: Capsule[] = fns.map(fn => fn.getCapsules()).flat();
 
   const batch = new BatchCall(sender, calls);
-  batch.addCapsules(capsules);
-  await batch.send().wait({ proven: waitUntilProven });
+
+  const txReceipt = await batch.send({ from: accountAddressesToDeploy[0] }).wait();
+  if (waitUntilProven) {
+    if (!pxeOrNode) {
+      throw new Error('Need to provide a PXE or AztecNode to wait for proven.');
+    } else {
+      await waitForProven(pxeOrNode, txReceipt);
+    }
+  }
 }