@aztec/end-to-end 4.0.0-nightly.20250907 → 4.0.0-nightly.20260108

package/src/bench/client_flows/data_extractor.ts

@@ -1,6 +1,4 @@
-import type { Logger } from '@aztec/aztec.js';
-import { BBNativePrivateKernelProver } from '@aztec/bb-prover/client/native';
-import { BBWASMBundlePrivateKernelProver } from '@aztec/bb-prover/client/wasm/bundle';
+import { BBBundlePrivateKernelProver } from '@aztec/bb-prover/client/bundle';
 import { createLogger, logger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { WASMSimulator } from '@aztec/simulator/client';
@@ -11,26 +9,7 @@ import { Decoder } from 'msgpackr';
 import { readFile, readdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 
-import { type Log, type ProverType, ProxyLogger, generateBenchmark } from './benchmark.js';
-
-type NativeProverConfig = { bbBinaryPath?: string; bbWorkingDirectory?: string };
-
-async function createProver(config: NativeProverConfig = {}, log: Logger) {
-  const simulator = new WASMSimulator();
-  if (!config.bbBinaryPath || !config.bbWorkingDirectory) {
-    return { prover: new BBWASMBundlePrivateKernelProver(simulator, 16, log), type: 'wasm' as ProverType };
-  } else {
-    const bbConfig = config as Required<NativeProverConfig>;
-    return {
-      prover: await BBNativePrivateKernelProver.new(
-        { bbSkipCleanup: false, numConcurrentIVCVerifiers: 1, bbIVCConcurrency: 1, ...bbConfig },
-        simulator,
-        log,
-      ),
-      type: 'native' as ProverType,
-    };
-  }
-}
+import { type Log, ProxyLogger, generateBenchmark } from './benchmark.js';
 
 async function main() {
   ProxyLogger.create();
@@ -41,12 +20,11 @@ async function main() {
   }
   const flows = await readdir(ivcFolder);
   logger.info(`Flows in ${ivcFolder}: \n${flows.map(flowName => `\t- ${flowName}`).join('\n')}`);
-  const { prover, type: proverType } = await createProver(
-    { bbBinaryPath: process.env.BB_BINARY_PATH, bbWorkingDirectory: process.env.BB_WORKING_DIRECTORY },
-    proxyLogger.createLogger('bb:prover'),
-  );
+  const simulator = new WASMSimulator();
+  const log = proxyLogger.createLogger('bb:prover');
+  const prover = new BBBundlePrivateKernelProver(simulator, { logger: log });
 
-  const userLog = createLogger('client_ivc_flows:data_processor');
+  const userLog = createLogger('chonk_flows:data_processor');
 
   for (const flow of flows) {
     userLog.info(`Processing flow ${flow}`);
@@ -84,10 +62,10 @@ async function main() {
     let provingTime;
     try {
       const provingTimer = new Timer();
-      await prover.createClientIvcProof(privateExecutionSteps);
+      await prover.createChonkProof(privateExecutionSteps);
       provingTime = provingTimer.ms();
     } catch (e) {
-      userLog.error(`Failed to generate client ivc proof for ${flow}`, e);
+      userLog.error(`Failed to generate chonk proof for ${flow}`, e);
       error = (e as Error).message;
     }
     // Extract logs from this run from the proxy and write them to disk unconditionally
@@ -96,7 +74,7 @@ async function main() {
     if (!(profile.stats.timings as ProvingTimings).proving) {
       (profile.stats.timings as ProvingTimings).proving = provingTime;
     }
-    const benchmark = generateBenchmark(flow, currentLogs, profile.stats, privateExecutionSteps, proverType, error);
+    const benchmark = generateBenchmark(flow, currentLogs, profile.stats, privateExecutionSteps, 'native', error);
     await writeFile(join(ivcFolder, flow, 'benchmark.json'), JSON.stringify(benchmark, null, 2));
     proxyLogger.flushLogs();
   }

package/src/bench/utils.ts

@@ -1,8 +1,8 @@
 import type { AztecNodeService } from '@aztec/aztec-node';
-import { type AztecNode, BatchCall, type SentTx, type WaitOpts } from '@aztec/aztec.js';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import { BatchCall, type SentTx, type WaitOpts } from '@aztec/aztec.js/contracts';
 import { mean, stdDev, times } from '@aztec/foundation/collection';
 import { BenchmarkingContract } from '@aztec/noir-test-contracts.js/Benchmarking';
-import { type PXEService, type PXEServiceConfig, createPXEService } from '@aztec/pxe/server';
 import type { MetricsType } from '@aztec/telemetry-client';
 import type { BenchmarkDataPoint, BenchmarkMetricsType, BenchmarkTelemetryClient } from '@aztec/telemetry-client/bench';
 
@@ -22,9 +22,8 @@ export async function benchmarkSetup(
   },
 ) {
   const context = await setup(1, { ...opts, telemetryConfig: { benchmark: true } });
-  const contract = await BenchmarkingContract.deploy(context.wallet)
-    .send({ from: context.wallet.getAddress() })
-    .deployed();
+  const defaultAccountAddress = context.accounts[0];
+  const contract = await BenchmarkingContract.deploy(context.wallet).send({ from: defaultAccountAddress }).deployed();
   context.logger.info(`Deployed benchmarking contract at ${contract.address}`);
   const sequencer = (context.aztecNode as AztecNodeService).getSequencer()!;
   const telemetry = context.telemetryClient! as BenchmarkTelemetryClient;
@@ -105,19 +104,22 @@ function getMetricValues(points: BenchmarkDataPoint[]) {
  * @param heavyPublicCompute - Whether the transactions include heavy public compute (like a big sha256).
  * @returns A BatchCall instance.
  */
-function makeCall(
+async function makeCall(
   index: number,
   context: EndToEndContext,
   contract: BenchmarkingContract,
   heavyPublicCompute: boolean,
 ) {
-  const owner = context.wallet.getAddress();
   if (heavyPublicCompute) {
-    return new BatchCall(context.wallet, [contract.methods.sha256_hash_2048(randomBytesAsBigInts(2048))]);
+    return new BatchCall(context.wallet, [contract.methods.sha256_hash_1024(randomBytesAsBigInts(1024))]);
   } else {
+    // We use random address for the new note owner because we can emit at most UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN
+    // logs for a given sender-recipient-contract tuple.
+    const ownerOfNewNote = await AztecAddress.random();
+    const [ownerOfBalance] = context.accounts;
     return new BatchCall(context.wallet, [
-      contract.methods.create_note(owner, index + 1),
-      contract.methods.increment_balance(owner, index + 1),
+      contract.methods.create_note(ownerOfNewNote, index + 1),
+      contract.methods.increment_balance(ownerOfBalance, index + 1),
     ]);
   }
 }
@@ -137,11 +139,11 @@ export async function sendTxs(
   contract: BenchmarkingContract,
   heavyPublicCompute: boolean = false,
 ): Promise<SentTx[]> {
-  const calls = times(txCount, index => makeCall(index, context, contract, heavyPublicCompute));
+  const calls = await Promise.all(times(txCount, index => makeCall(index, context, contract, heavyPublicCompute)));
   context.logger.info(`Creating ${txCount} txs`);
-  const provenTxs = await Promise.all(calls.map(call => call.prove({ from: context.wallet.getAddress() })));
+  const [from] = context.accounts;
   context.logger.info(`Sending ${txCount} txs`);
-  return provenTxs.map(tx => tx.send());
+  return calls.map(call => call.send({ from }));
 }
 
 export async function waitTxs(txs: SentTx[], context: EndToEndContext, txWaitOpts?: WaitOpts) {
@@ -150,32 +152,6 @@ export async function waitTxs(txs: SentTx[], context: EndToEndContext, txWaitOpt
   context.logger.info(`All ${txs.length} txs have been mined`);
 }
 
-/**
- * Creates a new PXE
- * @param node - Node to connect the pxe to.
- * @param contract - Benchmark contract to add to the pxe.
- * @param startingBlock - First l2 block to process.
- * @returns The new PXE.
- */
-export async function createNewPXE(node: AztecNode, contract: BenchmarkingContract): Promise<PXEService> {
-  const l1Contracts = await node.getL1ContractAddresses();
-  const { l1ChainId, rollupVersion } = await node.getNodeInfo();
-  const pxeConfig = {
-    l2BlockBatchSize: 50,
-    l2BlockPollingIntervalMS: 100,
-    dataDirectory: undefined,
-    dataStoreMapSizeKB: 1024 * 1024,
-    l1Contracts,
-    l1ChainId,
-    rollupVersion,
-  } as PXEServiceConfig;
-  // docs:start:PXEcreate
-  const pxe = await createPXEService(node, pxeConfig);
-  // docs:end:PXEcreate
-  await pxe.registerContract(contract);
-  return pxe;
-}
-
 function randomBytesAsBigInts(length: number): bigint[] {
   return [...Array(length)].map(_ => BigInt(Math.floor(Math.random() * 255)));
 }

package/src/e2e_blacklist_token_contract/blacklist_token_contract_test.ts

@@ -1,21 +1,15 @@
-import { getSchnorrWallet } from '@aztec/accounts/schnorr';
-import {
-  type AccountWallet,
-  AztecAddress,
-  type AztecNode,
-  type CompleteAddress,
-  Fr,
-  type Logger,
-  type PXE,
-  type TxHash,
-  computeSecretHash,
-  createLogger,
-} from '@aztec/aztec.js';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import { computeSecretHash } from '@aztec/aztec.js/crypto';
+import { Fr } from '@aztec/aztec.js/fields';
+import { type Logger, createLogger } from '@aztec/aztec.js/log';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import type { TxHash } from '@aztec/aztec.js/tx';
 import type { CheatCodes } from '@aztec/aztec/testing';
 import type { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { TokenBlacklistContract } from '@aztec/noir-contracts.js/TokenBlacklist';
 import { InvalidAccountContract } from '@aztec/noir-test-contracts.js/InvalidAccount';
 import type { SequencerClient } from '@aztec/sequencer-client';
+import type { TestWallet } from '@aztec/test-wallet/server';
 
 import { jest } from '@jest/globals';
 
@@ -63,9 +57,7 @@ export class BlacklistTokenContractTest {
 
   private snapshotManager: ISnapshotManager;
   logger: Logger;
-  wallets: AccountWallet[] = [];
-  pxe!: PXE;
-  accounts: CompleteAddress[] = [];
+  wallet!: TestWallet;
   asset!: TokenBlacklistContract;
   tokenSim!: TokenSimulator;
   badAccount!: InvalidAccountContract;
@@ -73,11 +65,8 @@ export class BlacklistTokenContractTest {
   sequencer!: SequencerClient;
   aztecNode!: AztecNode;
 
-  admin!: AccountWallet;
   adminAddress!: AztecAddress;
-  other!: AccountWallet;
   otherAddress!: AztecAddress;
-  blacklisted!: AccountWallet;
   blacklistedAddress!: AztecAddress;
 
   constructor(testName: string) {
@@ -105,19 +94,15 @@ export class BlacklistTokenContractTest {
     await this.snapshotManager.snapshot(
       '3_accounts',
       deployAccounts(3, this.logger),
-      async ({ deployedAccounts }, { pxe, cheatCodes, aztecNode, sequencer }) => {
-        this.pxe = pxe;
+      ({ deployedAccounts }, { cheatCodes, aztecNode, sequencer, wallet }) => {
         this.cheatCodes = cheatCodes;
         this.aztecNode = aztecNode;
         this.sequencer = sequencer;
-        this.wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
-        this.admin = this.wallets[0];
-        this.adminAddress = this.admin.getAddress();
-        this.other = this.wallets[1];
-        this.otherAddress = this.other.getAddress();
-        this.blacklisted = this.wallets[2];
-        this.blacklistedAddress = this.blacklisted.getAddress();
-        this.accounts = this.wallets.map(w => w.getCompleteAddress());
+        this.wallet = wallet;
+        this.adminAddress = deployedAccounts[0].address;
+        this.otherAddress = deployedAccounts[1].address;
+        this.blacklistedAddress = deployedAccounts[2].address;
+        return Promise.resolve();
       },
     );
 
@@ -127,16 +112,16 @@ export class BlacklistTokenContractTest {
         // Create the token contract state.
         // Move this account thing to addAccounts above?
         this.logger.verbose(`Public deploy accounts...`);
-        await publicDeployAccounts(this.admin, this.accounts.slice(0, 3));
+        await publicDeployAccounts(this.wallet, [this.adminAddress, this.otherAddress, this.blacklistedAddress]);
 
         this.logger.verbose(`Deploying TokenContract...`);
-        this.asset = await TokenBlacklistContract.deploy(this.admin, this.adminAddress)
+        this.asset = await TokenBlacklistContract.deploy(this.wallet, this.adminAddress)
           .send({ from: this.adminAddress })
           .deployed();
         this.logger.verbose(`Token deployed to ${this.asset.address}`);
 
         this.logger.verbose(`Deploying bad account...`);
-        this.badAccount = await InvalidAccountContract.deploy(this.admin).send({ from: this.adminAddress }).deployed();
+        this.badAccount = await InvalidAccountContract.deploy(this.wallet).send({ from: this.adminAddress }).deployed();
         this.logger.verbose(`Deployed to ${this.badAccount.address}.`);
 
         await this.crossTimestampOfChange();
@@ -145,18 +130,18 @@ export class BlacklistTokenContractTest {
       },
       async ({ tokenContractAddress, badAccountAddress }) => {
         // Restore the token contract state.
-        this.asset = await TokenBlacklistContract.at(tokenContractAddress, this.wallets[0]);
+        this.asset = TokenBlacklistContract.at(tokenContractAddress, this.wallet);
         this.logger.verbose(`Token contract address: ${this.asset.address}`);
 
         this.tokenSim = new TokenSimulator(
           this.asset as unknown as TokenContract,
-          this.admin,
+          this.wallet,
           this.adminAddress,
           this.logger,
-          this.accounts.map(a => a.address),
+          [this.adminAddress, this.otherAddress, this.blacklistedAddress],
         );
 
-        this.badAccount = await InvalidAccountContract.at(badAccountAddress, this.wallets[0]);
+        this.badAccount = InvalidAccountContract.at(badAccountAddress, this.wallet);
         this.logger.verbose(`Bad account address: ${this.badAccount.address}`);
 
         expect(await this.asset.methods.get_roles(this.adminAddress).simulate({ from: this.adminAddress })).toEqual(
@@ -187,7 +172,7 @@ export class BlacklistTokenContractTest {
     secretHash: Fr,
     txHash: TxHash,
   ) {
-    const txEffects = await this.pxe.getTxEffect(txHash);
+    const txEffects = await this.aztecNode.getTxEffect(txHash);
     await contract.methods
       .deliver_transparent_note(
         contract.address,
@@ -205,40 +190,38 @@ export class BlacklistTokenContractTest {
     await this.snapshotManager.snapshot(
       'mint',
       async () => {
-        const { asset, accounts, wallets } = this;
+        const { asset } = this;
         const amount = 10000n;
 
         const adminMinterRole = new Role().withAdmin().withMinter();
-        await this.asset
-          .withWallet(this.admin)
-          .methods.update_roles(this.admin.getAddress(), adminMinterRole.toNoirStruct())
+        await this.asset.methods
+          .update_roles(this.adminAddress, adminMinterRole.toNoirStruct())
           .send({ from: this.adminAddress })
           .wait();
 
         const blacklistRole = new Role().withBlacklisted();
-        await this.asset
-          .withWallet(this.admin)
-          .methods.update_roles(this.blacklisted.getAddress(), blacklistRole.toNoirStruct())
+        await this.asset.methods
+          .update_roles(this.blacklistedAddress, blacklistRole.toNoirStruct())
           .send({ from: this.adminAddress })
           .wait();
 
         await this.crossTimestampOfChange();
 
-        expect(
-          await this.asset.methods.get_roles(this.admin.getAddress()).simulate({ from: this.adminAddress }),
-        ).toEqual(adminMinterRole.toNoirStruct());
+        expect(await this.asset.methods.get_roles(this.adminAddress).simulate({ from: this.adminAddress })).toEqual(
+          adminMinterRole.toNoirStruct(),
+        );
 
         this.logger.verbose(`Minting ${amount} publicly...`);
-        await asset.methods.mint_public(accounts[0].address, amount).send({ from: this.adminAddress }).wait();
+        await asset.methods.mint_public(this.adminAddress, amount).send({ from: this.adminAddress }).wait();
 
         this.logger.verbose(`Minting ${amount} privately...`);
         const secret = Fr.random();
         const secretHash = await computeSecretHash(secret);
         const receipt = await asset.methods.mint_private(amount, secretHash).send({ from: this.adminAddress }).wait();
 
-        await this.addPendingShieldNoteToPXE(asset, wallets[0].getAddress(), amount, secretHash, receipt.txHash);
+        await this.addPendingShieldNoteToPXE(asset, this.adminAddress, amount, secretHash, receipt.txHash);
         const txClaim = asset.methods
-          .redeem_shield(accounts[0].address, amount, secret)
+          .redeem_shield(this.adminAddress, amount, secret)
           .send({ from: this.adminAddress });
         await txClaim.wait();
         this.logger.verbose(`Minting complete.`);
@@ -246,23 +229,23 @@ export class BlacklistTokenContractTest {
         return { amount };
       },
       async ({ amount }) => {
-        const {
-          asset,
-          accounts: [{ address }],
-          tokenSim,
-        } = this;
-        tokenSim.mintPublic(address, amount);
-
-        const publicBalance = await asset.methods.balance_of_public(address).simulate({ from: address });
+        const { asset, tokenSim } = this;
+        tokenSim.mintPublic(this.adminAddress, amount);
+
+        const publicBalance = await asset.methods
+          .balance_of_public(this.adminAddress)
+          .simulate({ from: this.adminAddress });
         this.logger.verbose(`Public balance of wallet 0: ${publicBalance}`);
-        expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(address));
+        expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(this.adminAddress));
 
-        tokenSim.mintPrivate(address, amount);
-        const privateBalance = await asset.methods.balance_of_private(address).simulate({ from: address });
+        tokenSim.mintPrivate(this.adminAddress, amount);
+        const privateBalance = await asset.methods
+          .balance_of_private(this.adminAddress)
+          .simulate({ from: this.adminAddress });
         this.logger.verbose(`Private balance of wallet 0: ${privateBalance}`);
-        expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(address));
+        expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(this.adminAddress));
 
-        const totalSupply = await asset.methods.total_supply().simulate({ from: address });
+        const totalSupply = await asset.methods.total_supply().simulate({ from: this.adminAddress });
         this.logger.verbose(`Total supply: ${totalSupply}`);
         expect(totalSupply).toEqual(tokenSim.totalSupply);
 

package/src/e2e_cross_chain_messaging/cross_chain_messaging_test.ts

@@ -1,26 +1,20 @@
-import { getSchnorrWallet } from '@aztec/accounts/schnorr';
 import type { AztecNodeConfig } from '@aztec/aztec-node';
-import {
-  type AccountWallet,
-  AztecAddress,
-  type AztecNode,
-  type CompleteAddress,
-  EthAddress,
-  type Logger,
-  type PXE,
-  createLogger,
-} from '@aztec/aztec.js';
+import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
+import { type Logger, createLogger } from '@aztec/aztec.js/log';
+import type { AztecNode } from '@aztec/aztec.js/node';
 import { CheatCodes } from '@aztec/aztec/testing';
-import {
-  type DeployL1ContractsReturnType,
-  type ExtendedViemWalletClient,
-  createExtendedL1Client,
-  deployL1Contract,
-} from '@aztec/ethereum';
+import { createExtendedL1Client } from '@aztec/ethereum/client';
+import type {
+  DeployAztecL1ContractsArgs,
+  DeployAztecL1ContractsReturnType,
+} from '@aztec/ethereum/deploy-aztec-l1-contracts';
+import { deployL1Contract } from '@aztec/ethereum/deploy-l1-contract';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
 import { InboxAbi, OutboxAbi, TestERC20Abi, TestERC20Bytecode } from '@aztec/l1-artifacts';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { TokenBridgeContract } from '@aztec/noir-contracts.js/TokenBridge';
 import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
+import type { TestWallet } from '@aztec/test-wallet/server';
 
 import { getContract } from 'viem';
 
@@ -32,6 +26,7 @@ import {
   deployAccounts,
   publicDeployAccounts,
 } from '../fixtures/snapshot_manager.js';
+import type { SetupOptions } from '../fixtures/utils.js';
 import { CrossChainTestHarness } from '../shared/cross_chain_test_harness.js';
 
 const { E2E_DATA_PATH: dataPath } = process.env;
@@ -39,21 +34,19 @@ const { E2E_DATA_PATH: dataPath } = process.env;
 export class CrossChainMessagingTest {
   private snapshotManager: ISnapshotManager;
   logger: Logger;
-  accounts: CompleteAddress[] = [];
   aztecNode!: AztecNode;
-  pxe!: PXE;
   aztecNodeConfig!: AztecNodeConfig;
   aztecNodeAdmin!: AztecNodeAdmin;
+  ctx!: SubsystemsContext;
 
   l1Client!: ExtendedViemWalletClient | undefined;
 
-  user1Wallet!: AccountWallet;
+  wallet!: TestWallet;
+  ownerAddress!: AztecAddress;
   user1Address!: AztecAddress;
-  user2Wallet!: AccountWallet;
   user2Address!: AztecAddress;
   crossChainTestHarness!: CrossChainTestHarness;
   ethAccount!: EthAddress;
-  ownerAddress!: AztecAddress;
   l2Token!: TokenContract;
   l2Bridge!: TokenBridgeContract;
 
@@ -61,11 +54,18 @@ export class CrossChainMessagingTest {
   outbox!: any; // GetContractReturnType<typeof OutboxAbi> | undefined;
   cheatCodes!: CheatCodes;
 
-  deployL1ContractsValues!: DeployL1ContractsReturnType;
+  deployL1ContractsValues!: DeployAztecL1ContractsReturnType;
 
-  constructor(testName: string) {
+  constructor(
+    testName: string,
+    opts: SetupOptions = {},
+    deployL1ContractsArgs: Partial<DeployAztecL1ContractsArgs> = {},
+  ) {
     this.logger = createLogger(`e2e:e2e_cross_chain_messaging:${testName}`);
-    this.snapshotManager = createSnapshotManager(`e2e_cross_chain_messaging/${testName}`, dataPath);
+    this.snapshotManager = createSnapshotManager(`e2e_cross_chain_messaging/${testName}`, dataPath, opts, {
+      initialValidators: [],
+      ...deployL1ContractsArgs,
+    });
   }
 
   async assumeProven() {
@@ -73,13 +73,13 @@ export class CrossChainMessagingTest {
   }
 
   async setup() {
-    const { aztecNode, pxe, aztecNodeConfig, deployL1ContractsValues } = await this.snapshotManager.setup();
-    this.aztecNode = aztecNode;
-    this.pxe = pxe;
-    this.aztecNodeConfig = aztecNodeConfig;
-    this.cheatCodes = await CheatCodes.create(this.aztecNodeConfig.l1RpcUrls, this.pxe);
-    this.deployL1ContractsValues = deployL1ContractsValues;
-    this.aztecNodeAdmin = aztecNode;
+    this.ctx = await this.snapshotManager.setup();
+    this.aztecNode = this.ctx.aztecNode;
+    this.wallet = this.ctx.wallet;
+    this.aztecNodeConfig = this.ctx.aztecNodeConfig;
+    this.cheatCodes = this.ctx.cheatCodes;
+    this.deployL1ContractsValues = this.ctx.deployL1ContractsValues;
+    this.aztecNodeAdmin = this.ctx.aztecNode;
   }
 
   snapshot = <T>(
@@ -93,25 +93,18 @@ export class CrossChainMessagingTest {
   }
 
   async applyBaseSnapshots() {
-    // Note that we are using the same `pxe`, `aztecNodeConfig` and `aztecNode` across all snapshots.
+    // Note that we are using the same `wallet`, `aztecNodeConfig` and `aztecNode` across all snapshots.
     // This is to not have issues with different networks.
 
     await this.snapshotManager.snapshot(
       '3_accounts',
       deployAccounts(3, this.logger),
-      async ({ deployedAccounts }, { pxe, aztecNodeConfig, aztecNode }) => {
-        const wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
-        this.accounts = wallets.map(w => w.getCompleteAddress());
-        wallets.forEach((w, i) => this.logger.verbose(`Wallet ${i} address: ${w.getAddress()}`));
-
-        this.user1Wallet = wallets[0];
-        this.user1Address = this.user1Wallet.getAddress();
-        this.user2Wallet = wallets[1];
-        this.user2Address = this.user2Wallet.getAddress();
-
-        this.pxe = pxe;
+      ({ deployedAccounts }, { wallet, aztecNodeConfig, aztecNode }) => {
+        [this.ownerAddress, this.user1Address, this.user2Address] = deployedAccounts.map(a => a.address);
+        this.wallet = wallet;
         this.aztecNode = aztecNode;
         this.aztecNodeConfig = aztecNodeConfig;
+        return Promise.resolve();
       },
     );
 
@@ -121,7 +114,7 @@ export class CrossChainMessagingTest {
         // Create the token contract state.
         // Move this account thing to addAccounts above?
         this.logger.verbose(`Public deploy accounts...`);
-        await publicDeployAccounts(this.user1Wallet, this.accounts.slice(0, 3));
+        await publicDeployAccounts(this.wallet, [this.ownerAddress, this.user1Address, this.user2Address]);
 
         this.l1Client = createExtendedL1Client(this.aztecNodeConfig.l1RpcUrls, MNEMONIC);
 
@@ -134,10 +127,9 @@ export class CrossChainMessagingTest {
         this.logger.verbose(`Setting up cross chain harness...`);
         this.crossChainTestHarness = await CrossChainTestHarness.new(
           this.aztecNode,
-          this.pxe,
           this.l1Client,
-          this.user1Wallet,
-          this.user1Address,
+          this.wallet,
+          this.ownerAddress,
           this.logger,
           underlyingERC20Address,
         );
@@ -146,13 +138,12 @@ export class CrossChainMessagingTest {
 
         return this.crossChainTestHarness.toCrossChainContext();
       },
-      async crossChainContext => {
-        this.l2Token = await TokenContract.at(crossChainContext.l2Token, this.user1Wallet);
-        this.l2Bridge = await TokenBridgeContract.at(crossChainContext.l2Bridge, this.user1Wallet);
+      crossChainContext => {
+        this.l2Token = TokenContract.at(crossChainContext.l2Token, this.wallet);
+        this.l2Bridge = TokenBridgeContract.at(crossChainContext.l2Bridge, this.wallet);
 
         // There is an issue with the reviver so we are getting strings sometimes. Working around it here.
         this.ethAccount = EthAddress.fromString(crossChainContext.ethAccount.toString());
-        this.ownerAddress = AztecAddress.fromString(crossChainContext.ownerAddress.toString());
         const tokenPortalAddress = EthAddress.fromString(crossChainContext.tokenPortal.toString());
 
         const l1Client = createExtendedL1Client(this.aztecNodeConfig.l1RpcUrls, MNEMONIC);
@@ -170,7 +161,6 @@ export class CrossChainMessagingTest {
 
         this.crossChainTestHarness = new CrossChainTestHarness(
           this.aztecNode,
-          this.pxe,
           this.logger,
           this.l2Token,
           this.l2Bridge,
@@ -179,13 +169,14 @@ export class CrossChainMessagingTest {
           crossChainContext.underlying,
           l1Client,
           this.aztecNodeConfig.l1Contracts,
-          this.user1Wallet,
-          this.user1Address,
+          this.wallet,
+          this.ownerAddress,
         );
 
         this.l1Client = l1Client;
         this.inbox = inbox;
         this.outbox = outbox;
+        return Promise.resolve();
       },
     );
   }