@aztec/end-to-end 0.0.1-commit.c7c42ec → 0.0.1-commit.f295ac2

package/src/e2e_blacklist_token_contract/blacklist_token_contract_test.ts

@@ -13,17 +13,9 @@ import type { TestWallet } from '@aztec/test-wallet/server';
 
 import { jest } from '@jest/globals';
 
-import {
-  type ISnapshotManager,
-  type SubsystemsContext,
-  createSnapshotManager,
-  deployAccounts,
-  publicDeployAccounts,
-} from '../fixtures/snapshot_manager.js';
+import { type EndToEndContext, deployAccounts, publicDeployAccounts, setup, teardown } from '../fixtures/setup.js';
 import { TokenSimulator } from '../simulators/token_simulator.js';
 
-const { E2E_DATA_PATH: dataPath } = process.env;
-
 export class Role {
   private isAdmin = false;
   private isMinter = false;
@@ -55,7 +47,7 @@ export class BlacklistTokenContractTest {
   // This value MUST match the same value that we have in the contract
   static CHANGE_ROLES_DELAY = 86400;
 
-  private snapshotManager: ISnapshotManager;
+  context!: EndToEndContext;
   logger: Logger;
   wallet!: TestWallet;
   asset!: TokenBlacklistContract;
@@ -71,7 +63,6 @@ export class BlacklistTokenContractTest {
 
   constructor(testName: string) {
     this.logger = createLogger(`e2e:e2e_blacklist_token_contract:${testName}`);
-    this.snapshotManager = createSnapshotManager(`e2e_blacklist_token_contract/${testName}`, dataPath);
   }
 
   async crossTimestampOfChange() {
@@ -83,86 +74,72 @@ export class BlacklistTokenContractTest {
   }
 
   /**
-   * Adds two state shifts to snapshot manager.
+   * Applies base setup:
    * 1. Add 3 accounts.
    * 2. Publicly deploy accounts, deploy token contract and a "bad account".
    */
-  async applyBaseSnapshots() {
+  async applyBaseSetup() {
     // Adding a timeout of 2 minutes in here such that it is propagated to the underlying tests
     jest.setTimeout(120_000);
 
-    await this.snapshotManager.snapshot(
-      '3_accounts',
-      deployAccounts(3, this.logger),
-      ({ deployedAccounts }, { cheatCodes, aztecNode, sequencer, wallet }) => {
-        this.cheatCodes = cheatCodes;
-        this.aztecNode = aztecNode;
-        this.sequencer = sequencer;
-        this.wallet = wallet;
-        this.adminAddress = deployedAccounts[0].address;
-        this.otherAddress = deployedAccounts[1].address;
-        this.blacklistedAddress = deployedAccounts[2].address;
-        return Promise.resolve();
-      },
+    this.logger.info('Deploying 3 accounts');
+    const { deployedAccounts } = await deployAccounts(
+      3,
+      this.logger,
+    )({
+      wallet: this.context.wallet,
+      initialFundedAccounts: this.context.initialFundedAccounts,
+    });
+
+    this.cheatCodes = this.context.cheatCodes;
+    this.aztecNode = this.context.aztecNodeService!;
+    this.sequencer = this.context.sequencer!;
+    this.wallet = this.context.wallet;
+    this.adminAddress = deployedAccounts[0].address;
+    this.otherAddress = deployedAccounts[1].address;
+    this.blacklistedAddress = deployedAccounts[2].address;
+
+    this.logger.info('Setting up blacklist token contract');
+    // Create the token contract state.
+    this.logger.verbose(`Public deploy accounts...`);
+    await publicDeployAccounts(this.wallet, [this.adminAddress, this.otherAddress, this.blacklistedAddress]);
+
+    this.logger.verbose(`Deploying TokenContract...`);
+    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.wallet).send({ from: this.adminAddress }).deployed();
+    this.logger.verbose(`Deployed to ${this.badAccount.address}.`);
+
+    await this.crossTimestampOfChange();
+
+    this.tokenSim = new TokenSimulator(
+      this.asset as unknown as TokenContract,
+      this.wallet,
+      this.adminAddress,
+      this.logger,
+      [this.adminAddress, this.otherAddress, this.blacklistedAddress],
     );
 
-    await this.snapshotManager.snapshot(
-      'e2e_blacklist_token_contract',
-      async () => {
-        // Create the token contract state.
-        // Move this account thing to addAccounts above?
-        this.logger.verbose(`Public deploy accounts...`);
-        await publicDeployAccounts(this.wallet, [this.adminAddress, this.otherAddress, this.blacklistedAddress]);
-
-        this.logger.verbose(`Deploying TokenContract...`);
-        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.wallet).send({ from: this.adminAddress }).deployed();
-        this.logger.verbose(`Deployed to ${this.badAccount.address}.`);
-
-        await this.crossTimestampOfChange();
-
-        return { tokenContractAddress: this.asset.address, badAccountAddress: this.badAccount.address };
-      },
-      async ({ tokenContractAddress, badAccountAddress }) => {
-        // Restore the token contract state.
-        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.wallet,
-          this.adminAddress,
-          this.logger,
-          [this.adminAddress, this.otherAddress, this.blacklistedAddress],
-        );
-
-        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(
-          new Role().withAdmin().toNoirStruct(),
-        );
-      },
+    expect(await this.asset.methods.get_roles(this.adminAddress).simulate({ from: this.adminAddress })).toEqual(
+      new Role().withAdmin().toNoirStruct(),
     );
   }
 
   async setup() {
-    await this.snapshotManager.setup();
+    this.logger.info('Setting up fresh context');
+    this.context = await setup(0, {
+      fundSponsoredFPC: true,
+      skipAccountDeployment: true,
+    });
+    await this.applyBaseSetup();
   }
 
-  snapshot = <T>(
-    name: string,
-    apply: (context: SubsystemsContext) => Promise<T>,
-    restore: (snapshotData: T, context: SubsystemsContext) => Promise<void> = () => Promise.resolve(),
-  ): Promise<void> => this.snapshotManager.snapshot(name, apply, restore);
-
   async teardown() {
-    await this.snapshotManager.teardown();
+    await teardown(this.context);
   }
 
   async addPendingShieldNoteToPXE(
@@ -174,7 +151,7 @@ export class BlacklistTokenContractTest {
   ) {
     const txEffects = await this.aztecNode.getTxEffect(txHash);
     await contract.methods
-      .deliver_transparent_note(
+      .process_transparent_note(
         contract.address,
         amount,
         secretHash,
@@ -186,71 +163,59 @@ export class BlacklistTokenContractTest {
       .simulate({ from: recipient });
   }
 
-  async applyMintSnapshot() {
-    await this.snapshotManager.snapshot(
-      'mint',
-      async () => {
-        const { asset } = this;
-        const amount = 10000n;
-
-        const adminMinterRole = new Role().withAdmin().withMinter();
-        await this.asset.methods
-          .update_roles(this.adminAddress, adminMinterRole.toNoirStruct())
-          .send({ from: this.adminAddress })
-          .wait();
-
-        const blacklistRole = new Role().withBlacklisted();
-        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.adminAddress).simulate({ from: this.adminAddress })).toEqual(
-          adminMinterRole.toNoirStruct(),
-        );
-
-        this.logger.verbose(`Minting ${amount} publicly...`);
-        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, this.adminAddress, amount, secretHash, receipt.txHash);
-        const txClaim = asset.methods
-          .redeem_shield(this.adminAddress, amount, secret)
-          .send({ from: this.adminAddress });
-        await txClaim.wait();
-        this.logger.verbose(`Minting complete.`);
-
-        return { amount };
-      },
-      async ({ amount }) => {
-        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(this.adminAddress));
-
-        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(this.adminAddress));
-
-        const totalSupply = await asset.methods.total_supply().simulate({ from: this.adminAddress });
-        this.logger.verbose(`Total supply: ${totalSupply}`);
-        expect(totalSupply).toEqual(tokenSim.totalSupply);
-
-        return Promise.resolve();
-      },
+  async applyMint() {
+    this.logger.info('Applying mint setup');
+    const { asset, tokenSim } = this;
+    const amount = 10000n;
+
+    const adminMinterRole = new Role().withAdmin().withMinter();
+    await this.asset.methods
+      .update_roles(this.adminAddress, adminMinterRole.toNoirStruct())
+      .send({ from: this.adminAddress })
+      .wait();
+
+    const blacklistRole = new Role().withBlacklisted();
+    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.adminAddress).simulate({ from: this.adminAddress })).toEqual(
+      adminMinterRole.toNoirStruct(),
     );
+
+    this.logger.verbose(`Minting ${amount} publicly...`);
+    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, this.adminAddress, amount, secretHash, receipt.txHash);
+    const txClaim = asset.methods.redeem_shield(this.adminAddress, amount, secret).send({ from: this.adminAddress });
+    await txClaim.wait();
+    this.logger.verbose(`Minting complete.`);
+
+    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(this.adminAddress));
+
+    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(this.adminAddress));
+
+    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,43 +1,46 @@
 import type { AztecNodeConfig } from '@aztec/aztec-node';
 import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
+import { waitForProven } from '@aztec/aztec.js/contracts';
 import { type Logger, createLogger } from '@aztec/aztec.js/log';
 import type { AztecNode } from '@aztec/aztec.js/node';
+import type { TxReceipt } from '@aztec/aztec.js/tx';
 import { CheatCodes } from '@aztec/aztec/testing';
 import { createExtendedL1Client } from '@aztec/ethereum/client';
+import { InboxContract, OutboxContract, RollupContract } from '@aztec/ethereum/contracts';
 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 { CheckpointNumber, EpochNumber } from '@aztec/foundation/branded-types';
+import { sleep } from '@aztec/foundation/sleep';
+import { 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';
-
 import { MNEMONIC } from '../fixtures/fixtures.js';
 import {
-  type ISnapshotManager,
-  type SubsystemsContext,
-  createSnapshotManager,
+  type EndToEndContext,
+  type SetupOptions,
   deployAccounts,
   publicDeployAccounts,
-} from '../fixtures/snapshot_manager.js';
-import type { SetupOptions } from '../fixtures/utils.js';
+  setup,
+  teardown,
+} from '../fixtures/setup.js';
 import { CrossChainTestHarness } from '../shared/cross_chain_test_harness.js';
 
-const { E2E_DATA_PATH: dataPath } = process.env;
-
 export class CrossChainMessagingTest {
-  private snapshotManager: ISnapshotManager;
+  private requireEpochProven: boolean;
+  private setupOptions: SetupOptions;
+  private deployL1ContractsArgs: Partial<DeployAztecL1ContractsArgs>;
   logger: Logger;
+  context!: EndToEndContext;
   aztecNode!: AztecNode;
   aztecNodeConfig!: AztecNodeConfig;
   aztecNodeAdmin!: AztecNodeAdmin;
-  ctx!: SubsystemsContext;
 
   l1Client!: ExtendedViemWalletClient | undefined;
 
@@ -50,8 +53,9 @@ export class CrossChainMessagingTest {
   l2Token!: TokenContract;
   l2Bridge!: TokenBridgeContract;
 
-  inbox!: any; // GetContractReturnType<typeof InboxAbi> | undefined;
-  outbox!: any; // GetContractReturnType<typeof OutboxAbi> | undefined;
+  rollup!: RollupContract;
+  inbox!: InboxContract;
+  outbox!: OutboxContract;
   cheatCodes!: CheatCodes;
 
   deployL1ContractsValues!: DeployAztecL1ContractsReturnType;
@@ -62,122 +66,129 @@ export class CrossChainMessagingTest {
     deployL1ContractsArgs: Partial<DeployAztecL1ContractsArgs> = {},
   ) {
     this.logger = createLogger(`e2e:e2e_cross_chain_messaging:${testName}`);
-    this.snapshotManager = createSnapshotManager(`e2e_cross_chain_messaging/${testName}`, dataPath, opts, {
+    this.setupOptions = opts;
+    this.deployL1ContractsArgs = {
       initialValidators: [],
       ...deployL1ContractsArgs,
-    });
+    };
+    this.requireEpochProven = opts.startProverNode ?? false;
   }
 
-  async assumeProven() {
-    await this.cheatCodes.rollup.markAsProven();
+  async setup() {
+    this.logger.info('Setting up cross chain messaging test');
+    this.context = await setup(0, {
+      ...this.setupOptions,
+      fundSponsoredFPC: true,
+      skipAccountDeployment: true,
+      l1ContractsArgs: this.deployL1ContractsArgs,
+    });
+    await this.applyBaseSetup();
   }
 
-  async setup() {
-    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;
+  async advanceToEpochProven(l2TxReceipt: TxReceipt): Promise<EpochNumber> {
+    const epoch = await this.rollup.getEpochNumberForCheckpoint(
+      CheckpointNumber.fromBlockNumber(l2TxReceipt.blockNumber!),
+    );
+    // Warp to the next epoch.
+    await this.cheatCodes.rollup.advanceToEpoch(EpochNumber(epoch + 1));
+    // Wait for the tx to be proven.
+    await waitForProven(this.aztecNode, l2TxReceipt, { provenTimeout: 300 });
+    // Return the epoch the tx is in.
+    return epoch;
   }
 
-  snapshot = <T>(
-    name: string,
-    apply: (context: SubsystemsContext) => Promise<T>,
-    restore: (snapshotData: T, context: SubsystemsContext) => Promise<void> = () => Promise.resolve(),
-  ): Promise<void> => this.snapshotManager.snapshot(name, apply, restore);
+  async catchUpProvenChain() {
+    const bn = await this.aztecNode.getBlockNumber();
+    while ((await this.aztecNode.getProvenBlockNumber()) < bn) {
+      await sleep(1000);
+    }
+  }
 
   async teardown() {
-    await this.snapshotManager.teardown();
+    await teardown(this.context);
   }
 
-  async applyBaseSnapshots() {
-    // 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),
-      ({ 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();
-      },
+  async applyBaseSetup() {
+    // Set up base context fields
+    this.aztecNode = this.context.aztecNodeService!;
+    this.wallet = this.context.wallet;
+    this.aztecNodeConfig = this.context.config;
+    this.cheatCodes = this.context.cheatCodes;
+    this.deployL1ContractsValues = this.context.deployL1ContractsValues;
+    this.aztecNodeAdmin = this.context.aztecNodeService!;
+
+    if (this.requireEpochProven) {
+      // Turn off the watcher to prevent it from keep marking blocks as proven.
+      this.context.watcher!.setIsMarkingAsProven(false);
+    }
+
+    // Deploy 3 accounts
+    this.logger.info('Applying 3_accounts setup');
+    const { deployedAccounts } = await deployAccounts(
+      3,
+      this.logger,
+    )({
+      wallet: this.context.wallet,
+      initialFundedAccounts: this.context.initialFundedAccounts,
+    });
+    [this.ownerAddress, this.user1Address, this.user2Address] = deployedAccounts.map(a => a.address);
+
+    // Set up cross chain messaging
+    this.logger.info('Applying e2e_cross_chain_messaging setup');
+
+    // Create the token contract state.
+    this.logger.verbose(`Public deploy accounts...`);
+    await publicDeployAccounts(this.wallet, [this.ownerAddress, this.user1Address, this.user2Address]);
+
+    this.l1Client = createExtendedL1Client(this.aztecNodeConfig.l1RpcUrls, MNEMONIC);
+
+    const underlyingERC20Address = await deployL1Contract(this.l1Client, TestERC20Abi, TestERC20Bytecode, [
+      'Underlying',
+      'UND',
+      this.l1Client.account.address,
+    ]).then(({ address }) => address);
+
+    this.logger.verbose(`Setting up cross chain harness...`);
+    this.crossChainTestHarness = await CrossChainTestHarness.new(
+      this.aztecNode,
+      this.l1Client,
+      this.wallet,
+      this.ownerAddress,
+      this.logger,
+      underlyingERC20Address,
     );
 
-    await this.snapshotManager.snapshot(
-      'e2e_cross_chain_messaging',
-      async () => {
-        // Create the token contract state.
-        // Move this account thing to addAccounts above?
-        this.logger.verbose(`Public deploy accounts...`);
-        await publicDeployAccounts(this.wallet, [this.ownerAddress, this.user1Address, this.user2Address]);
-
-        this.l1Client = createExtendedL1Client(this.aztecNodeConfig.l1RpcUrls, MNEMONIC);
-
-        const underlyingERC20Address = await deployL1Contract(this.l1Client, TestERC20Abi, TestERC20Bytecode, [
-          'Underlying',
-          'UND',
-          this.l1Client.account.address,
-        ]).then(({ address }) => address);
-
-        this.logger.verbose(`Setting up cross chain harness...`);
-        this.crossChainTestHarness = await CrossChainTestHarness.new(
-          this.aztecNode,
-          this.l1Client,
-          this.wallet,
-          this.ownerAddress,
-          this.logger,
-          underlyingERC20Address,
-        );
-
-        this.logger.verbose(`L2 token deployed to: ${this.crossChainTestHarness.l2Token.address}`);
-
-        return this.crossChainTestHarness.toCrossChainContext();
-      },
-      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());
-        const tokenPortalAddress = EthAddress.fromString(crossChainContext.tokenPortal.toString());
-
-        const l1Client = createExtendedL1Client(this.aztecNodeConfig.l1RpcUrls, MNEMONIC);
-
-        const inbox = getContract({
-          address: this.aztecNodeConfig.l1Contracts.inboxAddress.toString(),
-          abi: InboxAbi,
-          client: l1Client,
-        });
-        const outbox = getContract({
-          address: this.aztecNodeConfig.l1Contracts.outboxAddress.toString(),
-          abi: OutboxAbi,
-          client: l1Client,
-        });
-
-        this.crossChainTestHarness = new CrossChainTestHarness(
-          this.aztecNode,
-          this.logger,
-          this.l2Token,
-          this.l2Bridge,
-          this.ethAccount,
-          tokenPortalAddress,
-          crossChainContext.underlying,
-          l1Client,
-          this.aztecNodeConfig.l1Contracts,
-          this.wallet,
-          this.ownerAddress,
-        );
-
-        this.l1Client = l1Client;
-        this.inbox = inbox;
-        this.outbox = outbox;
-        return Promise.resolve();
-      },
+    this.logger.verbose(`L2 token deployed to: ${this.crossChainTestHarness.l2Token.address}`);
+
+    const crossChainContext = this.crossChainTestHarness.toCrossChainContext();
+
+    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());
+    const tokenPortalAddress = EthAddress.fromString(crossChainContext.tokenPortal.toString());
+
+    const l1Client = createExtendedL1Client(this.aztecNodeConfig.l1RpcUrls, MNEMONIC);
+    this.l1Client = l1Client;
+
+    const l1Contracts = this.aztecNodeConfig.l1Contracts;
+    this.rollup = new RollupContract(l1Client, l1Contracts.rollupAddress.toString());
+    this.inbox = new InboxContract(l1Client, l1Contracts.inboxAddress.toString());
+    this.outbox = new OutboxContract(l1Client, l1Contracts.outboxAddress.toString());
+
+    this.crossChainTestHarness = new CrossChainTestHarness(
+      this.aztecNode,
+      this.logger,
+      this.l2Token,
+      this.l2Bridge,
+      this.ethAccount,
+      tokenPortalAddress,
+      crossChainContext.underlying,
+      l1Client,
+      this.aztecNodeConfig.l1Contracts,
+      this.wallet,
+      this.ownerAddress,
     );
   }
 }

package/src/e2e_deploy_contract/deploy_test.ts

@@ -10,12 +10,10 @@ import type { StatefulTestContract } from '@aztec/noir-test-contracts.js/Statefu
 import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 import type { TestWallet } from '@aztec/test-wallet/server';
 
-import { type ISnapshotManager, createSnapshotManager, deployAccounts } from '../fixtures/snapshot_manager.js';
-
-const { E2E_DATA_PATH: dataPath } = process.env;
+import { type EndToEndContext, deployAccounts, setup, teardown } from '../fixtures/setup.js';
 
 export class DeployTest {
-  private snapshotManager: ISnapshotManager;
+  public context!: EndToEndContext;
   public logger: Logger;
   public wallet!: TestWallet;
   public defaultAccountAddress!: AztecAddress;
@@ -24,26 +22,35 @@ export class DeployTest {
 
   constructor(testName: string) {
     this.logger = createLogger(`e2e:e2e_deploy_contract:${testName}`);
-    this.snapshotManager = createSnapshotManager(`e2e_deploy_contract/${testName}`, dataPath);
   }
 
   async setup() {
-    await this.applyInitialAccountSnapshot();
-    const context = await this.snapshotManager.setup();
-    ({ aztecNode: this.aztecNode, wallet: this.wallet } = context);
-    this.aztecNodeAdmin = context.aztecNode;
+    this.logger.info('Setting up test environment');
+    this.context = await setup(0, {
+      fundSponsoredFPC: true,
+      skipAccountDeployment: true,
+    });
+    this.aztecNode = this.context.aztecNodeService!;
+    this.wallet = this.context.wallet;
+    this.aztecNodeAdmin = this.context.aztecNodeService!;
+    await this.applyInitialAccount();
     return this;
   }
 
   async teardown() {
-    await this.snapshotManager.teardown();
+    await teardown(this.context);
   }
 
-  private async applyInitialAccountSnapshot() {
-    await this.snapshotManager.snapshot('initial_account', deployAccounts(1, this.logger), ({ deployedAccounts }) => {
-      this.defaultAccountAddress = deployedAccounts[0].address;
-      return Promise.resolve();
+  private async applyInitialAccount() {
+    this.logger.info('Applying initial account setup');
+    const { deployedAccounts } = await deployAccounts(
+      1,
+      this.logger,
+    )({
+      wallet: this.context.wallet,
+      initialFundedAccounts: this.context.initialFundedAccounts,
     });
+    this.defaultAccountAddress = deployedAccounts[0].address;
   }
 
   async registerContract<T extends ContractBase>(