@aztec/end-to-end 0.0.0-test.1 → 0.0.1-commit.03f7ef2

package/src/fixtures/snapshot_manager.ts

@@ -1,50 +1,62 @@
 import { SchnorrAccountContractArtifact } from '@aztec/accounts/schnorr';
-import { type InitialAccountData, deployFundedSchnorrAccounts, generateSchnorrAccounts } from '@aztec/accounts/testing';
+import { type InitialAccountData, generateSchnorrAccounts } from '@aztec/accounts/testing';
 import { type AztecNodeConfig, AztecNodeService, getConfigEnvVars } from '@aztec/aztec-node';
+import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
+import { getContractClassFromArtifact } from '@aztec/aztec.js/contracts';
+import { BatchCall, type ContractFunctionInteraction, waitForProven } from '@aztec/aztec.js/contracts';
+import { publishContractClass, publishInstance } from '@aztec/aztec.js/deployment';
+import type { Logger } from '@aztec/aztec.js/log';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import type { Wallet } from '@aztec/aztec.js/wallet';
+import { AnvilTestWatcher, CheatCodes } from '@aztec/aztec/testing';
+import { createBlobClientWithFileStores } from '@aztec/blob-client/client';
+import { createExtendedL1Client } from '@aztec/ethereum/client';
+import { getL1ContractsConfigEnvVars } from '@aztec/ethereum/config';
+import { deployMulticall3 } from '@aztec/ethereum/contracts';
 import {
-  AnvilTestWatcher,
-  type AztecAddress,
-  BatchCall,
-  type Capsule,
-  CheatCodes,
-  type CompleteAddress,
-  type ContractFunctionInteraction,
-  type DeployL1ContractsReturnType,
-  type FunctionCall,
-  type Logger,
-  type PXE,
-  type Wallet,
-  getContractClassFromArtifact,
-} from '@aztec/aztec.js';
-import { deployInstance, registerContractClass } from '@aztec/aztec.js/deployment';
-import { type BlobSinkServer, createBlobSinkServer } from '@aztec/blob-sink/server';
-import { type DeployL1ContractsArgs, createL1Clients, getL1ContractsConfigEnvVars, l1Artifacts } from '@aztec/ethereum';
+  type DeployAztecL1ContractsArgs,
+  type DeployAztecL1ContractsReturnType,
+  deployAztecL1Contracts,
+} from '@aztec/ethereum/deploy-aztec-l1-contracts';
 import { EthCheatCodesWithState, startAnvil } from '@aztec/ethereum/test';
 import { asyncMap } from '@aztec/foundation/async-map';
-import { randomBytes } from '@aztec/foundation/crypto';
+import { SecretValue } from '@aztec/foundation/config';
+import { randomBytes } from '@aztec/foundation/crypto/random';
+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 { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
 import type { ProverNode } from '@aztec/prover-node';
-import { type PXEService, createPXEService, getPXEServiceConfig } from '@aztec/pxe/server';
+import { getPXEConfig } 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 { TestWallet } from '@aztec/test-wallet/server';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
 import type { Anvil } from '@viem/anvil';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { copySync, removeSync } from 'fs-extra/esm';
 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,
+  setupSharedBlobStorage,
+} from './utils.js';
 import { getEndToEndTestTelemetryClient } from './with_telemetry_utils.js';
 
 export type SubsystemsContext = {
@@ -53,13 +65,13 @@ export type SubsystemsContext = {
   bbConfig: any;
   aztecNode: AztecNodeService;
   aztecNodeConfig: AztecNodeConfig;
-  pxe: PXEService;
-  deployL1ContractsValues: DeployL1ContractsReturnType;
+  wallet: TestWallet;
+  deployL1ContractsValues: DeployAztecL1ContractsReturnType;
   proverNode?: ProverNode;
   watcher: AnvilTestWatcher;
   cheatCodes: CheatCodes;
+  sequencer: SequencerClient;
   dateProvider: TestDateProvider;
-  blobSink: BlobSinkServer;
   initialFundedAccounts: InitialAccountData[];
   directoryToCleanup?: string;
 };
@@ -75,7 +87,7 @@ export function createSnapshotManager(
   testName: string,
   dataPath?: string,
   config: Partial<SetupOptions> = {},
-  deployL1ContractsArgs: Partial<DeployL1ContractsArgs> = {
+  deployL1ContractsArgs: Partial<DeployAztecL1ContractsArgs> = {
     initialValidators: [],
   },
 ) {
@@ -104,7 +116,7 @@ class MockSnapshotManager implements ISnapshotManager {
   constructor(
     testName: string,
     private config: Partial<AztecNodeConfig> = {},
-    private deployL1ContractsArgs: Partial<DeployL1ContractsArgs> = {},
+    private deployL1ContractsArgs: Partial<DeployAztecL1ContractsArgs> = {},
   ) {
     this.logger = createLogger(`e2e:snapshot_manager:${testName}`);
     this.logger.warn(`No data path given, will not persist any snapshots.`);
@@ -152,7 +164,7 @@ class SnapshotManager implements ISnapshotManager {
     testName: string,
     private dataPath: string,
     private config: Partial<SetupOptions> = {},
-    private deployL1ContractsArgs: Partial<DeployL1ContractsArgs> = {},
+    private deployL1ContractsArgs: Partial<DeployAztecL1ContractsArgs> = {},
   ) {
     this.livePath = join(this.dataPath, 'live', testName);
     this.logger = createLogger(`e2e:snapshot_manager:${testName}`);
@@ -188,7 +200,7 @@ class SnapshotManager implements ISnapshotManager {
     await restore(snapshotData, context);
 
     // Save the snapshot data.
-    const ethCheatCodes = new EthCheatCodesWithState(context.aztecNodeConfig.l1RpcUrls);
+    const ethCheatCodes = new EthCheatCodesWithState(context.aztecNodeConfig.l1RpcUrls, context.dateProvider);
     const anvilStateFile = `${this.livePath}/anvil.dat`;
     await ethCheatCodes.dumpChainState(anvilStateFile);
     writeFileSync(`${this.livePath}/${name}.json`, JSON.stringify(snapshotData || {}, resolver));
@@ -253,24 +265,18 @@ 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 tryRmDir(context.directoryToCleanup, logger);
   } catch (err) {
-    getLogger().error('Error during teardown', err);
+    logger.error('Error during teardown', err);
   }
 }
 
@@ -283,18 +289,30 @@ async function setupFromFresh(
   statePath: string | undefined,
   logger: Logger,
   { numberOfInitialFundedAccounts = 10, ...opts }: SetupOptions = {},
-  deployL1ContractsArgs: Partial<DeployL1ContractsArgs> = {
+  deployL1ContractsArgs: Partial<DeployAztecL1ContractsArgs> = {
     initialValidators: [],
   },
 ): Promise<SubsystemsContext> {
   logger.verbose(`Initializing state...`);
 
-  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 +322,77 @@ 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];
+  await setupSharedBlobStorage(aztecNodeConfig);
 
-  // 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 publisherPrivKeyHex = `0x${publisherPrivKey!.toString('hex')}` satisfies `0x${string}`;
+
+  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(publisherPrivKeyHex)];
+  aztecNodeConfig.validatorPrivateKeys = new SecretValue([`0x${validatorPrivKey!.toString('hex')}`]);
+  aztecNodeConfig.coinbase = opts.coinbase ?? EthAddress.fromString(`${hdAccount.address}`);
 
-  const ethCheatCodes = new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls);
+  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 dateProvider = new TestDateProvider();
+  const ethCheatCodes = new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls, dateProvider);
+
+  // Deploy our L1 contracts.
+  logger.verbose('Deploying Aztec 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,
   );
 
-  const deployL1ContractsValues = await setupL1Contracts(aztecNodeConfig.l1RpcUrls[0], hdAccount, logger, {
+  const vkTreeRoot = getVKTreeRoot();
+  await deployMulticall3(l1Client, logger);
+
+  // Define args, defaulted to our environment variables.
+  const args: DeployAztecL1ContractsArgs = {
     ...getL1ContractsConfigEnvVars(),
-    genesisArchiveRoot,
-    genesisBlockHash,
-    salt: opts.salt,
     ...deployL1ContractsArgs,
+    vkTreeRoot,
+    genesisArchiveRoot,
+    protocolContractsHash,
     initialValidators: opts.initialValidators,
-  });
-  aztecNodeConfig.l1Contracts = deployL1ContractsValues.l1ContractAddresses;
-  aztecNodeConfig.l1PublishRetryIntervalMS = 100;
-
-  if (opts.fundRewardDistributor) {
-    // Mints block rewards for 10000 blocks to the rewardDistributor contract
-
-    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);
+    feeJuicePortalInitialBalance: fundingNeeded,
+    realVerifier: false,
+  };
 
-    const feeJuice = getContract({
-      address: deployL1ContractsValues.l1ContractAddresses.feeJuiceAddress.toString(),
-      abi: l1Artifacts.feeAsset.contractAbi,
-      client: deployL1ContractsValues.walletClient,
-    });
+  const deployL1ContractsValues = await deployAztecL1Contracts(
+    aztecNodeConfig.l1RpcUrls[0],
+    publisherPrivKeyHex,
+    foundry.id,
+    args,
+  );
 
-    const rewardDistributorMintTxHash = await feeJuice.write.mint([rewardDistributor.address, mintAmount], {} as any);
-    await deployL1ContractsValues.publicClient.waitForTransactionReceipt({ hash: rewardDistributorMintTxHash });
-    logger.info(`Funding rewardDistributor in ${rewardDistributorMintTxHash}`);
-  }
+  aztecNodeConfig.l1Contracts = deployL1ContractsValues.l1ContractAddresses;
+  aztecNodeConfig.rollupVersion = deployL1ContractsValues.rollupVersion;
 
   const watcher = new AnvilTestWatcher(
-    new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls),
+    new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls, dateProvider),
     deployL1ContractsValues.l1ContractAddresses.rollupAddress,
-    deployL1ContractsValues.publicClient,
+    deployL1ContractsValues.l1Client,
+    dateProvider,
   );
   await watcher.start();
 
@@ -399,34 +408,40 @@ async function setupFromFresh(
     aztecNodeConfig.bbWorkingDirectory = bbConfig.bbWorkingDirectory;
   }
 
-  const telemetry = getEndToEndTestTelemetryClient(opts.metricsPort);
+  const telemetry = await getEndToEndTestTelemetryClient(opts.metricsPort);
 
-  logger.verbose('Creating and synching an aztec node...');
-  const dateProvider = new TestDateProvider();
+  const blobClient = await createBlobClientWithFileStores(aztecNodeConfig, createLogger('node:blob-client:client'));
+
+  logger.info('Creating and synching an aztec node...');
   const aztecNode = await AztecNodeService.createAndSync(
     aztecNodeConfig,
-    { telemetry, dateProvider },
+    { telemetry, dateProvider, blobClient },
     { prefilledPublicData },
   );
 
   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,
     );
   }
 
   logger.verbose('Creating pxe...');
-  const pxeConfig = getPXEServiceConfig();
+  const pxeConfig = getPXEConfig();
   pxeConfig.dataDirectory = statePath ?? path.join(directoryToCleanup, randomBytes(8).toString('hex'));
-  const pxe = await createPXEService(aztecNode, pxeConfig);
-
-  const cheatCodes = await CheatCodes.create(aztecNodeConfig.l1RpcUrls, pxe);
+  // Only enable proving if specifically requested.
+  pxeConfig.proverEnabled = !!opts.realProofs;
+  const wallet = await TestWallet.create(aztecNode, pxeConfig);
+  const cheatCodes = await CheatCodes.create(aztecNodeConfig.l1RpcUrls, aztecNode, dateProvider);
 
   if (statePath) {
     writeFileSync(`${statePath}/aztec_node_config.json`, JSON.stringify(aztecNodeConfig, resolver));
@@ -437,7 +452,8 @@ async function setupFromFresh(
     aztecNodeConfig,
     anvil,
     aztecNode,
-    pxe,
+    wallet,
+    sequencer: aztecNode.getSequencer()!,
     acvmConfig,
     bbConfig,
     deployL1ContractsValues,
@@ -445,7 +461,6 @@ async function setupFromFresh(
     watcher,
     cheatCodes,
     dateProvider,
-    blobSink,
     initialFundedAccounts,
     directoryToCleanup,
   };
@@ -460,36 +475,28 @@ async function setupFromState(statePath: string, logger: Logger): Promise<Subsys
   const directoryToCleanup = path.join(tmpdir(), randomBytes(8).toString('hex'));
   await fs.mkdir(directoryToCleanup, { recursive: true });
 
-  // Run the blob sink on a random port
-  const blobSinkPort = await getPort();
-
   // TODO: For some reason this is currently the union of a bunch of subsystems. That needs fixing.
   const aztecNodeConfig: AztecNodeConfig & SetupOptions = JSON.parse(
     readFileSync(`${statePath}/aztec_node_config.json`, 'utf-8'),
     reviver,
   );
   aztecNodeConfig.dataDirectory = statePath;
-  aztecNodeConfig.blobSinkUrl = `http://127.0.0.1:${blobSinkPort}`;
+  aztecNodeConfig.listenAddress = '127.0.0.1';
+
+  await setupSharedBlobStorage(aztecNodeConfig);
 
   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];
   // Load anvil state.
   const anvilStateFile = `${statePath}/anvil.dat`;
-  const ethCheatCodes = new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls);
+
+  const dateProvider = new TestDateProvider();
+  const ethCheatCodes = new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls, dateProvider);
   await ethCheatCodes.loadChainState(anvilStateFile);
 
   // TODO: Encapsulate this in a NativeAcvm impl.
@@ -506,21 +513,24 @@ 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),
+    ethCheatCodes,
     aztecNodeConfig.l1Contracts.rollupAddress,
-    publicClient,
+    l1Client,
+    dateProvider,
   );
   await watcher.start();
 
+  const telemetry = await initTelemetryClient(getTelemetryConfig());
+
+  const blobClient = await createBlobClientWithFileStores(aztecNodeConfig, createLogger('node:blob-client:client'));
+
   logger.verbose('Creating aztec node...');
-  const telemetry = initTelemetryClient(getTelemetryConfig());
-  const dateProvider = new TestDateProvider();
   const aztecNode = await AztecNodeService.createAndSync(
     aztecNodeConfig,
-    { telemetry, dateProvider },
+    { telemetry, dateProvider, blobClient },
     { prefilledPublicData },
   );
 
@@ -532,36 +542,39 @@ 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,
     );
   }
 
   logger.verbose('Creating pxe...');
-  const pxeConfig = getPXEServiceConfig();
+  const pxeConfig = getPXEConfig();
   pxeConfig.dataDirectory = statePath;
-  const pxe = await createPXEService(aztecNode, pxeConfig);
-
-  const cheatCodes = await CheatCodes.create(aztecNodeConfig.l1RpcUrls, pxe);
+  const wallet = await TestWallet.create(aztecNode, pxeConfig);
+  const cheatCodes = await CheatCodes.create(aztecNodeConfig.l1RpcUrls, aztecNode, dateProvider);
 
   return {
     aztecNodeConfig,
     anvil,
     aztecNode,
-    pxe,
+    wallet,
+    sequencer: aztecNode.getSequencer()!,
     acvmConfig,
     bbConfig,
     proverNode,
     deployL1ContractsValues: {
-      walletClient,
-      publicClient,
+      l1Client,
       l1ContractAddresses: aztecNodeConfig.l1Contracts,
+      rollupVersion: aztecNodeConfig.rollupVersion,
     },
     watcher,
     cheatCodes,
     dateProvider,
-    blobSink,
     initialFundedAccounts,
     directoryToCleanup,
   };
@@ -572,15 +585,29 @@ async function setupFromState(statePath: string, logger: Logger): Promise<Subsys
  * The 'restore' function is not provided, as it must be a closure within the test context to capture the results.
  */
 export const deployAccounts =
-  (numberOfAccounts: number, logger: Logger, waitUntilProven = false) =>
-  async ({ pxe, initialFundedAccounts }: { pxe: PXE; initialFundedAccounts: InitialAccountData[] }) => {
+  (numberOfAccounts: number, logger: Logger) =>
+  async ({ wallet, initialFundedAccounts }: { wallet: TestWallet; initialFundedAccounts: InitialAccountData[] }) => {
     if (initialFundedAccounts.length < numberOfAccounts) {
       throw new Error(`Cannot deploy more than ${initialFundedAccounts.length} initial accounts.`);
     }
 
     logger.verbose('Deploying accounts funded with fee juice...');
     const deployedAccounts = initialFundedAccounts.slice(0, numberOfAccounts);
-    await deployFundedSchnorrAccounts(pxe, deployedAccounts, { proven: waitUntilProven });
+    // Serial due to https://github.com/AztecProtocol/aztec-packages/issues/12045
+    for (let i = 0; i < deployedAccounts.length; i++) {
+      const accountManager = await wallet.createSchnorrAccount(
+        deployedAccounts[i].secret,
+        deployedAccounts[i].salt,
+        deployedAccounts[i].signingKey,
+      );
+      const deployMethod = await accountManager.getDeployMethod();
+      await deployMethod
+        .send({
+          from: AztecAddress.ZERO,
+          skipClassPublication: i !== 0, // Publish the contract class at most once.
+        })
+        .wait();
+    }
 
     return { deployedAccounts };
   };
@@ -590,28 +617,35 @@ 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 node - AztecNode used to wait for proven tx.
  */
 export async function publicDeployAccounts(
-  sender: Wallet,
-  accountsToDeploy: (CompleteAddress | AztecAddress)[],
+  wallet: Wallet,
+  accountsToDeploy: AztecAddress[],
   waitUntilProven = false,
+  node?: AztecNode,
 ) {
-  const accountAddressesToDeploy = accountsToDeploy.map(a => ('address' in a ? a.address : a));
-  const instances = (
-    await Promise.all(accountAddressesToDeploy.map(account => sender.getContractMetadata(account)))
-  ).map(metadata => metadata.contractInstance);
+  const instances = (await Promise.all(accountsToDeploy.map(account => wallet.getContractMetadata(account)))).map(
+    metadata => metadata.contractInstance,
+  );
 
   const contractClass = await getContractClassFromArtifact(SchnorrAccountContractArtifact);
-  const alreadyRegistered = (await sender.getContractClassMetadata(contractClass.id)).isContractClassPubliclyRegistered;
+  const alreadyRegistered = (await wallet.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(wallet, SchnorrAccountContractArtifact)] : []),
+    ...instances.map(instance => publishInstance(wallet, 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 batch = new BatchCall(wallet, calls);
+
+  const txReceipt = await batch.send({ from: accountsToDeploy[0] }).wait();
+  if (waitUntilProven) {
+    if (!node) {
+      throw new Error('Need to provide an AztecNode to wait for proven.');
+    } else {
+      await waitForProven(node, txReceipt);
+    }
+  }
 }