@aztec/end-to-end 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2 → 0.77.0-testnet-ignition.21

package/src/e2e_cross_chain_messaging/cross_chain_messaging_test.ts

@@ -1,28 +1,29 @@
-import { getSchnorrAccount } from '@aztec/accounts/schnorr';
-import { type AztecNodeConfig } from '@aztec/aztec-node';
+import { getSchnorrWallet } from '@aztec/accounts/schnorr';
+import type { AztecNodeConfig } from '@aztec/aztec-node';
 import {
   type AccountWallet,
   AztecAddress,
   type AztecNode,
+  CheatCodes,
   type CompleteAddress,
   EthAddress,
   type Logger,
   type PXE,
   createLogger,
 } from '@aztec/aztec.js';
-import { createL1Clients } from '@aztec/ethereum';
-import { InboxAbi, OutboxAbi, RollupAbi } from '@aztec/l1-artifacts';
+import { type ViemPublicClient, createL1Clients, deployL1Contract } from '@aztec/ethereum';
+import { InboxAbi, OutboxAbi, RollupAbi, TestERC20Abi, TestERC20Bytecode } from '@aztec/l1-artifacts';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { TokenBridgeContract } from '@aztec/noir-contracts.js/TokenBridge';
 
-import { type Chain, type HttpTransport, type PublicClient, getContract } from 'viem';
+import { getContract } from 'viem';
 
 import { MNEMONIC } from '../fixtures/fixtures.js';
 import {
   type ISnapshotManager,
   type SubsystemsContext,
-  addAccounts,
   createSnapshotManager,
+  deployAccounts,
   publicDeployAccounts,
 } from '../fixtures/snapshot_manager.js';
 import { CrossChainTestHarness } from '../shared/cross_chain_test_harness.js';
@@ -38,7 +39,7 @@ export class CrossChainMessagingTest {
   pxe!: PXE;
   aztecNodeConfig!: AztecNodeConfig;
 
-  publicClient!: PublicClient<HttpTransport, Chain> | undefined;
+  publicClient!: ViemPublicClient | undefined;
 
   user1Wallet!: AccountWallet;
   user2Wallet!: AccountWallet;
@@ -51,6 +52,7 @@ export class CrossChainMessagingTest {
   rollup!: any; // GetContractReturnType<typeof RollupAbi> | undefined;
   inbox!: any; // GetContractReturnType<typeof InboxAbi> | undefined;
   outbox!: any; // GetContractReturnType<typeof OutboxAbi> | undefined;
+  cheatcodes!: CheatCodes;
 
   constructor(testName: string) {
     this.logger = createLogger(`e2e:e2e_cross_chain_messaging:${testName}`);
@@ -58,7 +60,7 @@ export class CrossChainMessagingTest {
   }
 
   async assumeProven() {
-    await this.rollup.write.setAssumeProvenThroughBlockNumber([await this.rollup.read.getPendingBlockNumber()]);
+    await this.cheatcodes.rollup.markAsProven(await this.rollup.read.getPendingBlockNumber());
   }
 
   async setup() {
@@ -66,6 +68,7 @@ export class CrossChainMessagingTest {
     this.aztecNode = aztecNode;
     this.pxe = pxe;
     this.aztecNodeConfig = aztecNodeConfig;
+    this.cheatcodes = await CheatCodes.create(this.aztecNodeConfig.l1RpcUrls, this.pxe);
   }
 
   snapshot = <T>(
@@ -84,14 +87,9 @@ export class CrossChainMessagingTest {
 
     await this.snapshotManager.snapshot(
       '3_accounts',
-      addAccounts(3, this.logger),
-      async ({ accountKeys }, { pxe, aztecNodeConfig, aztecNode, deployL1ContractsValues }) => {
-        this.wallets = await Promise.all(
-          accountKeys.map(async ak => {
-            const account = await getSchnorrAccount(pxe, ak[0], ak[1], 1);
-            return account.getWallet();
-          }),
-        );
+      deployAccounts(3, this.logger),
+      async ({ deployedAccounts }, { pxe, aztecNodeConfig, aztecNode, deployL1ContractsValues }) => {
+        this.wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
         this.accounts = this.wallets.map(w => w.getCompleteAddress());
         this.wallets.forEach((w, i) => this.logger.verbose(`Wallet ${i} address: ${w.getAddress()}`));
 
@@ -118,7 +116,24 @@ export class CrossChainMessagingTest {
         this.logger.verbose(`Public deploy accounts...`);
         await publicDeployAccounts(this.wallets[0], this.accounts.slice(0, 3));
 
-        const { publicClient, walletClient } = createL1Clients(this.aztecNodeConfig.l1RpcUrl, MNEMONIC);
+        const { publicClient, walletClient } = createL1Clients(this.aztecNodeConfig.l1RpcUrls, MNEMONIC);
+
+        const underlyingERC20Address = await deployL1Contract(
+          walletClient,
+          publicClient,
+          TestERC20Abi,
+          TestERC20Bytecode,
+          ['Underlying', 'UND', walletClient.account.address],
+        ).then(({ address }) => address);
+
+        const underlyingERC20 = getContract({
+          address: underlyingERC20Address!.toString(),
+          abi: TestERC20Abi,
+          client: walletClient,
+        });
+
+        // allow anyone to mint
+        await underlyingERC20.write.setFreeForAll([true], {} as any);
 
         this.logger.verbose(`Setting up cross chain harness...`);
         this.crossChainTestHarness = await CrossChainTestHarness.new(
@@ -128,6 +143,7 @@ export class CrossChainMessagingTest {
           walletClient,
           this.wallets[0],
           this.logger,
+          underlyingERC20Address,
         );
 
         this.logger.verbose(`L2 token deployed to: ${this.crossChainTestHarness.l2Token.address}`);
@@ -143,7 +159,7 @@ export class CrossChainMessagingTest {
         this.ownerAddress = AztecAddress.fromString(crossChainContext.ownerAddress.toString());
         const tokenPortalAddress = EthAddress.fromString(crossChainContext.tokenPortal.toString());
 
-        const { publicClient, walletClient } = createL1Clients(this.aztecNodeConfig.l1RpcUrl, MNEMONIC);
+        const { publicClient, walletClient } = createL1Clients(this.aztecNodeConfig.l1RpcUrls, MNEMONIC);
 
         const inbox = getContract({
           address: this.aztecNodeConfig.l1Contracts.inboxAddress.toString(),

package/src/e2e_deploy_contract/deploy_test.ts

@@ -1,4 +1,4 @@
-import { getSchnorrAccount } from '@aztec/accounts/schnorr';
+import { getSchnorrWallet } from '@aztec/accounts/schnorr';
 import {
   type AccountWallet,
   type AztecAddress,
@@ -13,9 +13,9 @@ import {
   createLogger,
   getContractInstanceFromDeployParams,
 } from '@aztec/aztec.js';
-import { type StatefulTestContract } from '@aztec/noir-contracts.js/StatefulTest';
+import type { StatefulTestContract } from '@aztec/noir-contracts.js/StatefulTest';
 
-import { type ISnapshotManager, addAccounts, createSnapshotManager } from '../fixtures/snapshot_manager.js';
+import { type ISnapshotManager, createSnapshotManager, deployAccounts } from '../fixtures/snapshot_manager.js';
 
 const { E2E_DATA_PATH: dataPath } = process.env;
 
@@ -47,14 +47,9 @@ export class DeployTest {
   private async applyInitialAccountSnapshot() {
     await this.snapshotManager.snapshot(
       'initial_account',
-      addAccounts(1, this.logger),
-      async ({ accountKeys }, { pxe }) => {
-        this.wallets = await Promise.all(
-          accountKeys.map(async ak => {
-            const account = await getSchnorrAccount(pxe, ak[0], ak[1], 1);
-            return account.getWallet();
-          }),
-        );
+      deployAccounts(1, this.logger),
+      async ({ deployedAccounts }, { pxe }) => {
+        this.wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
         this.wallets.forEach((w, i) => this.logger.verbose(`Wallet ${i} address: ${w.getAddress()}`));
         this.wallet = this.wallets[0];
       },

package/src/e2e_epochs/epochs_test.ts

@@ -0,0 +1,217 @@
+import { AztecNodeService } from '@aztec/aztec-node';
+import { Fr, type Logger, getTimestampRangeForEpoch, retryUntil, sleep } from '@aztec/aztec.js';
+import { ChainMonitor } from '@aztec/aztec.js/ethereum';
+import { RollupContract } from '@aztec/ethereum/contracts';
+import { DelayedTxUtils, type Delayer, waitUntilL1Timestamp } from '@aztec/ethereum/test';
+import { randomBytes } from '@aztec/foundation/crypto';
+import { withLogNameSuffix } from '@aztec/foundation/log';
+import { ProverNode, ProverNodePublisher } from '@aztec/prover-node';
+import type { TestProverNode } from '@aztec/prover-node/test';
+import type { SequencerPublisher } from '@aztec/sequencer-client';
+import type { TestSequencerClient } from '@aztec/sequencer-client/test';
+import type { L2BlockNumber } from '@aztec/stdlib/block';
+import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+
+import { join } from 'path';
+import type { Hex, PublicClient } from 'viem';
+
+import {
+  type EndToEndContext,
+  type SetupOptions,
+  createAndSyncProverNode,
+  getPrivateKeyFromIndex,
+  setup,
+} from '../fixtures/utils.js';
+
+// This can be lowered to as much as 2s in non-CI
+export const L1_BLOCK_TIME_IN_S = process.env.L1_BLOCK_TIME ? parseInt(process.env.L1_BLOCK_TIME) : 8;
+export const EPOCH_DURATION_IN_L2_SLOTS = 4;
+export const L2_SLOT_DURATION_IN_L1_SLOTS = 2;
+export const WORLD_STATE_BLOCK_HISTORY = 2;
+export const WORLD_STATE_BLOCK_CHECK_INTERVAL = 50;
+export const ARCHIVER_POLL_INTERVAL = 50;
+
+export type EpochsTestOpts = Partial<Pick<SetupOptions, 'startProverNode'>>;
+
+/**
+ * Tests building of epochs using fast block times and short epochs.
+ * Spawns an aztec node and a prover node with fake proofs.
+ * Sequencer is allowed to build empty blocks.
+ */
+export class EpochsTestContext {
+  public context!: EndToEndContext;
+  public l1Client!: PublicClient;
+  public rollup!: RollupContract;
+  public constants!: L1RollupConstants;
+  public logger!: Logger;
+  public monitor!: ChainMonitor;
+  public proverDelayer!: Delayer;
+  public sequencerDelayer!: Delayer;
+
+  public proverNodes: ProverNode[] = [];
+  public nodes: AztecNodeService[] = [];
+
+  public static async setup(opts: EpochsTestOpts = {}) {
+    const test = new EpochsTestContext();
+    await test.setup(opts);
+    return test;
+  }
+
+  public async setup(opts: EpochsTestOpts = {}) {
+    // Set up system without any account nor protocol contracts
+    // and with faster block times and shorter epochs.
+    const context = await setup(0, {
+      checkIntervalMs: 50,
+      archiverPollingIntervalMS: ARCHIVER_POLL_INTERVAL,
+      worldStateBlockCheckIntervalMS: WORLD_STATE_BLOCK_CHECK_INTERVAL,
+      skipProtocolContracts: true,
+      salt: 1,
+      aztecEpochDuration: EPOCH_DURATION_IN_L2_SLOTS,
+      aztecSlotDuration: L1_BLOCK_TIME_IN_S * L2_SLOT_DURATION_IN_L1_SLOTS,
+      ethereumSlotDuration: L1_BLOCK_TIME_IN_S,
+      aztecProofSubmissionWindow: EPOCH_DURATION_IN_L2_SLOTS * 2 - 1,
+      minTxsPerBlock: 0,
+      realProofs: false,
+      startProverNode: true,
+      // We use numeric incremental prover ids for simplicity, but we can switch to
+      // using the prover's eth address if the proverId is used for something in the rollup contract
+      proverId: Fr.fromString('1'),
+      // This must be enough so that the tx from the prover is delayed properly,
+      // but not so much to hang the sequencer and timeout the teardown
+      txPropagationMaxQueryAttempts: 12,
+      worldStateBlockHistory: WORLD_STATE_BLOCK_HISTORY,
+      ...opts,
+    });
+
+    this.context = context;
+    this.proverNodes = context.proverNode ? [context.proverNode] : [];
+    this.nodes = context.aztecNode ? [context.aztecNode as AztecNodeService] : [];
+    this.logger = context.logger;
+    this.l1Client = context.deployL1ContractsValues.publicClient;
+    this.rollup = RollupContract.getFromConfig(context.config);
+
+    // Loop that tracks L1 and L2 block numbers and logs whenever there's a new one.
+    this.monitor = new ChainMonitor(this.rollup, this.logger).start();
+
+    // This is hideous.
+    // We ought to have a definite reference to the l1TxUtils that we're using in both places, provided by the test context.
+    this.proverDelayer = context.proverNode
+      ? (((context.proverNode as TestProverNode).publisher as ProverNodePublisher).l1TxUtils as DelayedTxUtils).delayer!
+      : undefined!;
+    this.sequencerDelayer = (
+      ((context.sequencer as TestSequencerClient).sequencer.publisher as SequencerPublisher).l1TxUtils as DelayedTxUtils
+    ).delayer!;
+
+    if ((context.proverNode && !this.proverDelayer) || !this.sequencerDelayer) {
+      throw new Error(`Could not find prover or sequencer delayer`);
+    }
+
+    // Constants used for time calculation
+    this.constants = {
+      epochDuration: EPOCH_DURATION_IN_L2_SLOTS,
+      slotDuration: L1_BLOCK_TIME_IN_S * L2_SLOT_DURATION_IN_L1_SLOTS,
+      l1StartBlock: await this.rollup.getL1StartBlock(),
+      l1GenesisTime: await this.rollup.getL1GenesisTime(),
+      ethereumSlotDuration: L1_BLOCK_TIME_IN_S,
+    };
+
+    this.logger.info(
+      `L2 genesis at L1 block ${this.constants.l1StartBlock} (timestamp ${this.constants.l1GenesisTime})`,
+    );
+  }
+
+  public async teardown() {
+    this.monitor.stop();
+    await Promise.all(this.proverNodes.map(node => node.stop()));
+    await Promise.all(this.nodes.map(node => node.stop()));
+    await this.context.teardown();
+  }
+
+  public async createProverNode() {
+    this.logger.warn('Creating and syncing a simulated prover node...');
+    const proverNodePrivateKey = this.getNextPrivateKey();
+    const suffix = (this.proverNodes.length + 1).toString();
+    const proverNode = await withLogNameSuffix(suffix, () =>
+      createAndSyncProverNode(
+        proverNodePrivateKey,
+        { ...this.context.config, proverId: Fr.fromString(suffix) },
+        this.context.aztecNode,
+        join(this.context.config.dataDirectory!, randomBytes(8).toString('hex')),
+      ),
+    );
+    this.proverNodes.push(proverNode);
+    return proverNode;
+  }
+
+  public async createNonValidatorNode() {
+    this.logger.warn('Creating and syncing a node without a validator...');
+    const suffix = (this.nodes.length + 1).toString();
+    const node = await withLogNameSuffix(suffix, () =>
+      AztecNodeService.createAndSync({
+        ...this.context.config,
+        disableValidator: true,
+        dataDirectory: join(this.context.config.dataDirectory!, randomBytes(8).toString('hex')),
+      }),
+    );
+    this.nodes.push(node);
+    return node;
+  }
+
+  private getNextPrivateKey(): Hex {
+    const key = getPrivateKeyFromIndex(this.nodes.length + this.proverNodes.length + 1);
+    return `0x${key!.toString('hex')}`;
+  }
+
+  /** Waits until the epoch begins (ie until the immediately previous L1 block is mined). */
+  public async waitUntilEpochStarts(epoch: number) {
+    const [start] = getTimestampRangeForEpoch(BigInt(epoch), this.constants);
+    this.logger.info(`Waiting until L1 timestamp ${start} is reached as the start of epoch ${epoch}`);
+    await waitUntilL1Timestamp(this.l1Client, start - BigInt(L1_BLOCK_TIME_IN_S));
+    return start;
+  }
+
+  /** Waits until the given L2 block number is mined. */
+  public async waitUntilL2BlockNumber(target: number, timeout = 60) {
+    await retryUntil(
+      () => Promise.resolve(target === this.monitor.l2BlockNumber),
+      `Wait until L2 block ${target}`,
+      timeout,
+      0.1,
+    );
+  }
+
+  /** Waits until the given L2 block number is marked as proven. */
+  public async waitUntilProvenL2BlockNumber(t: number, timeout = 60) {
+    await retryUntil(
+      () => Promise.resolve(t === this.monitor.l2ProvenBlockNumber),
+      `Wait proven L2 block ${t}`,
+      timeout,
+      0.1,
+    );
+  }
+
+  /** Waits for the aztec node to sync to the target block number. */
+  public async waitForNodeToSync(blockNumber: number, type: 'finalised' | 'historic') {
+    const waitTime = ARCHIVER_POLL_INTERVAL + WORLD_STATE_BLOCK_CHECK_INTERVAL;
+    let synched = false;
+    while (!synched) {
+      await sleep(waitTime);
+      const syncState = await this.context.aztecNode.getWorldStateSyncStatus();
+      if (type === 'finalised') {
+        synched = syncState.finalisedBlockNumber >= blockNumber;
+      } else {
+        synched = syncState.oldestHistoricBlockNumber >= blockNumber;
+      }
+    }
+  }
+
+  /** Verifies whether the given block number is found on the aztec node. */
+  public async verifyHistoricBlock(blockNumber: L2BlockNumber, expectedSuccess: boolean) {
+    const result = await this.context.aztecNode
+      .findBlockNumbersForIndexes(blockNumber, MerkleTreeId.NULLIFIER_TREE, [0n])
+      .then(_ => true)
+      .catch(_ => false);
+    expect(result).toBe(expectedSuccess);
+  }
+}

package/src/e2e_fees/fees_test.ts

@@ -1,19 +1,19 @@
-import { getSchnorrAccount } from '@aztec/accounts/schnorr';
+import { getSchnorrWallet } from '@aztec/accounts/schnorr';
 import {
   type AccountWallet,
   type AztecAddress,
   type AztecNode,
+  ChainMonitor,
   CheatCodes,
   type Logger,
   type PXE,
-  SignerlessWallet,
   createLogger,
   sleep,
 } from '@aztec/aztec.js';
-import { DefaultMultiCallEntrypoint } from '@aztec/aztec.js/entrypoint';
-import { EthAddress, FEE_FUNDING_FOR_TESTER_ACCOUNT, GasSettings, computePartialAddress } from '@aztec/circuits.js';
-import { createL1Clients } from '@aztec/ethereum';
-import { TestERC20Abi } from '@aztec/l1-artifacts';
+import { FEE_FUNDING_FOR_TESTER_ACCOUNT } from '@aztec/constants';
+import { type DeployL1ContractsArgs, RollupContract, createL1Clients } from '@aztec/ethereum';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { RollupAbi, TestERC20Abi } from '@aztec/l1-artifacts';
 import { AppSubscriptionContract } from '@aztec/noir-contracts.js/AppSubscription';
 import { CounterContract } from '@aztec/noir-contracts.js/Counter';
 import { FPCContract } from '@aztec/noir-contracts.js/FPC';
@@ -21,14 +21,22 @@ import { FeeJuiceContract } from '@aztec/noir-contracts.js/FeeJuice';
 import { TokenContract as BananaCoin } from '@aztec/noir-contracts.js/Token';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { getCanonicalFeeJuice } from '@aztec/protocol-contracts/fee-juice';
+import { computePartialAddress } from '@aztec/stdlib/contract';
+import { GasSettings } from '@aztec/stdlib/gas';
 
 import { getContract } from 'viem';
 
 import { MNEMONIC } from '../fixtures/fixtures.js';
-import { type ISnapshotManager, addAccounts, createSnapshotManager } from '../fixtures/snapshot_manager.js';
+import {
+  type ISnapshotManager,
+  type SubsystemsContext,
+  createSnapshotManager,
+  deployAccounts,
+} from '../fixtures/snapshot_manager.js';
 import { mintTokensToPrivate } from '../fixtures/token_utils.js';
 import {
   type BalancesFn,
+  type SetupOptions,
   ensureAccountsPubliclyDeployed,
   getBalancesFn,
   setupCanonicalFeeJuice,
@@ -73,30 +81,56 @@ export class FeesTest {
   public subscriptionContract!: AppSubscriptionContract;
   public feeJuiceBridgeTestHarness!: GasBridgingTestHarness;
 
+  public context!: SubsystemsContext;
+  public chainMonitor!: ChainMonitor;
+
   public getCoinbaseBalance!: () => Promise<bigint>;
+  public getCoinbaseSequencerRewards!: () => Promise<bigint>;
   public getGasBalanceFn!: BalancesFn;
   public getBananaPublicBalanceFn!: BalancesFn;
   public getBananaPrivateBalanceFn!: BalancesFn;
+  public getProverFee!: (blockNumber: number) => Promise<bigint>;
 
   public readonly ALICE_INITIAL_BANANAS = BigInt(1e22);
   public readonly SUBSCRIPTION_AMOUNT = BigInt(1e19);
   public readonly APP_SPONSORED_TX_GAS_LIMIT = BigInt(10e9);
 
-  constructor(testName: string) {
+  constructor(
+    testName: string,
+    private numberOfAccounts = 3,
+    setupOptions: Partial<SetupOptions & DeployL1ContractsArgs> = {},
+  ) {
+    if (!numberOfAccounts) {
+      throw new Error('There must be at least 1 initial account.');
+    }
     this.logger = createLogger(`e2e:e2e_fees:${testName}`);
-    this.snapshotManager = createSnapshotManager(`e2e_fees/${testName}`, dataPath);
+    this.snapshotManager = createSnapshotManager(
+      `e2e_fees/${testName}-${numberOfAccounts}`,
+      dataPath,
+      { startProverNode: true, ...setupOptions },
+      { ...setupOptions },
+    );
   }
 
   async setup() {
     const context = await this.snapshotManager.setup();
     await context.aztecNode.setConfig({ feeRecipient: this.sequencerAddress, coinbase: this.coinbase });
+
+    const rollupContract = RollupContract.getFromConfig(context.aztecNodeConfig);
+    this.chainMonitor = new ChainMonitor(rollupContract, this.logger, 200).start();
+
     return this;
   }
 
   async teardown() {
+    this.chainMonitor.stop();
     await this.snapshotManager.teardown();
   }
 
+  setIsMarkingAsProven(b: boolean) {
+    this.context.watcher.setIsMarkingAsProven(b);
+  }
+
   async catchUpProvenChain() {
     const bn = await this.aztecNode.getBlockNumber();
     while ((await this.aztecNode.getProvenBlockNumber()) < bn) {
@@ -130,31 +164,29 @@ export class FeesTest {
   async applyInitialAccountsSnapshot() {
     await this.snapshotManager.snapshot(
       'initial_accounts',
-      addAccounts(3, this.logger),
-      async ({ accountKeys }, { pxe, aztecNode, aztecNodeConfig }) => {
+      deployAccounts(this.numberOfAccounts, this.logger),
+      async ({ deployedAccounts }, { pxe, aztecNode, aztecNodeConfig }) => {
         this.pxe = pxe;
         this.aztecNode = aztecNode;
         this.gasSettings = GasSettings.default({ maxFeesPerGas: (await this.aztecNode.getCurrentBaseFees()).mul(2) });
-        this.cheatCodes = await CheatCodes.create(aztecNodeConfig.l1RpcUrl, pxe);
-        const accountManagers = await Promise.all(accountKeys.map(ak => getSchnorrAccount(pxe, ak[0], ak[1], 1)));
-        await Promise.all(accountManagers.map(a => a.register()));
-        this.wallets = await Promise.all(accountManagers.map(a => a.getWallet()));
+        this.cheatCodes = await CheatCodes.create(aztecNodeConfig.l1RpcUrls, pxe);
+        this.wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
         this.wallets.forEach((w, i) => this.logger.verbose(`Wallet ${i} address: ${w.getAddress()}`));
         [this.aliceWallet, this.bobWallet] = this.wallets.slice(0, 2);
         [this.aliceAddress, this.bobAddress, this.sequencerAddress] = this.wallets.map(w => w.getAddress());
 
         // We set Alice as the FPC admin to avoid the need for deployment of another account.
         this.fpcAdmin = this.aliceAddress;
+
         const canonicalFeeJuice = await getCanonicalFeeJuice();
         this.feeJuiceContract = await FeeJuiceContract.at(canonicalFeeJuice.address, this.aliceWallet);
-        const bobInstance = (await this.bobWallet.getContractMetadata(this.bobAddress)).contractInstance;
-        if (!bobInstance) {
-          throw new Error('Bob instance not found');
+        if (this.numberOfAccounts > 1) {
+          const bobInstance = (await this.bobWallet.getContractMetadata(this.bobAddress)).contractInstance;
+          await this.aliceWallet.registerAccount(deployedAccounts[1].secret, await computePartialAddress(bobInstance!));
         }
-        await this.aliceWallet.registerAccount(accountKeys[1][0], await computePartialAddress(bobInstance));
         this.coinbase = EthAddress.random();
 
-        const { publicClient, walletClient } = createL1Clients(aztecNodeConfig.l1RpcUrl, MNEMONIC);
+        const { publicClient, walletClient } = createL1Clients(aztecNodeConfig.l1RpcUrls, MNEMONIC);
         this.feeJuiceBridgeTestHarness = await FeeJuicePortalTestingHarnessFactory.create({
           aztecNode: aztecNode,
           pxeService: pxe,
@@ -177,19 +209,16 @@ export class FeesTest {
     await this.snapshotManager.snapshot(
       'setup_fee_juice',
       async context => {
-        await setupCanonicalFeeJuice(
-          new SignerlessWallet(
-            context.pxe,
-            new DefaultMultiCallEntrypoint(context.aztecNodeConfig.l1ChainId, context.aztecNodeConfig.version),
-          ),
-        );
+        await setupCanonicalFeeJuice(context.pxe);
       },
       async (_data, context) => {
+        this.context = context;
+
         this.feeJuiceContract = await FeeJuiceContract.at(ProtocolContractAddress.FeeJuice, this.aliceWallet);
 
         this.getGasBalanceFn = getBalancesFn('⛽', this.feeJuiceContract.methods.balance_of_public, this.logger);
 
-        const { publicClient, walletClient } = createL1Clients(context.aztecNodeConfig.l1RpcUrl, MNEMONIC);
+        const { publicClient, walletClient } = createL1Clients(context.aztecNodeConfig.l1RpcUrls, MNEMONIC);
         this.feeJuiceBridgeTestHarness = await FeeJuicePortalTestingHarnessFactory.create({
           aztecNode: context.aztecNode,
           pxeService: context.pxe,
@@ -238,6 +267,7 @@ export class FeesTest {
           bananaFPCAddress: bananaFPC.address,
           feeJuiceAddress: feeJuiceContract.address,
           l1FeeJuiceAddress: this.feeJuiceBridgeTestHarness.l1FeeJuiceAddress,
+          rollupAddress: context.deployL1ContractsValues.l1ContractAddresses.rollupAddress,
         };
       },
       async (data, context) => {
@@ -253,7 +283,7 @@ export class FeesTest {
         );
 
         this.getCoinbaseBalance = async () => {
-          const { walletClient } = createL1Clients(context.aztecNodeConfig.l1RpcUrl, MNEMONIC);
+          const { walletClient } = createL1Clients(context.aztecNodeConfig.l1RpcUrls, MNEMONIC);
           const gasL1 = getContract({
             address: data.l1FeeJuiceAddress.toString(),
             abi: TestERC20Abi,
@@ -261,6 +291,32 @@ export class FeesTest {
           });
           return await gasL1.read.balanceOf([this.coinbase.toString()]);
         };
+
+        this.getCoinbaseSequencerRewards = async () => {
+          const { walletClient } = createL1Clients(context.aztecNodeConfig.l1RpcUrls, MNEMONIC);
+          const rollup = getContract({
+            address: data.rollupAddress.toString(),
+            abi: RollupAbi,
+            client: walletClient,
+          });
+
+          return await rollup.read.getSequencerRewards([this.coinbase.toString()]);
+        };
+
+        this.getProverFee = async (blockNumber: number) => {
+          const { walletClient } = createL1Clients(context.aztecNodeConfig.l1RpcUrls, MNEMONIC);
+          const rollup = getContract({
+            address: data.rollupAddress.toString(),
+            abi: RollupAbi,
+            client: walletClient,
+          });
+
+          const provingCostPerMana = await rollup.read.getProvingCostPerManaInFeeAsset();
+
+          const block = await this.pxe.getBlock(blockNumber);
+          const mana = block!.header.totalManaUsed.toBigInt();
+          return mana * provingCostPerMana;
+        };
       },
     );
   }
@@ -286,16 +342,6 @@ export class FeesTest {
     );
   }
 
-  public async applyFundAliceWithFeeJuice() {
-    await this.snapshotManager.snapshot(
-      'fund_alice_with_fee_juice',
-      async () => {
-        await this.mintAndBridgeFeeJuice(this.aliceAddress, FEE_FUNDING_FOR_TESTER_ACCOUNT);
-      },
-      () => Promise.resolve(),
-    );
-  }
-
   public async applySetupSubscription() {
     await this.snapshotManager.snapshot(
       'setup_subscription',

package/src/e2e_nested_contract/nested_contract_test.ts

@@ -1,4 +1,4 @@
-import { getSchnorrAccount } from '@aztec/accounts/schnorr';
+import { getSchnorrWallet } from '@aztec/accounts/schnorr';
 import { type AccountWallet, type CompleteAddress, type Logger, type PXE, createLogger } from '@aztec/aztec.js';
 import { ChildContract } from '@aztec/noir-contracts.js/Child';
 import { ParentContract } from '@aztec/noir-contracts.js/Parent';
@@ -6,8 +6,8 @@ import { ParentContract } from '@aztec/noir-contracts.js/Parent';
 import {
   type ISnapshotManager,
   type SubsystemsContext,
-  addAccounts,
   createSnapshotManager,
+  deployAccounts,
   publicDeployAccounts,
 } from '../fixtures/snapshot_manager.js';
 
@@ -23,9 +23,9 @@ export class NestedContractTest {
   parentContract!: ParentContract;
   childContract!: ChildContract;
 
-  constructor(testName: string) {
+  constructor(testName: string, private numberOfAccounts = 1) {
     this.logger = createLogger(`e2e:e2e_nested_contract:${testName}`);
-    this.snapshotManager = createSnapshotManager(`e2e_nested_contract/${testName}`, dataPath);
+    this.snapshotManager = createSnapshotManager(`e2e_nested_contract/${testName}-${numberOfAccounts}`, dataPath);
   }
 
   /**
@@ -34,18 +34,16 @@ export class NestedContractTest {
    * 2. Publicly deploy accounts
    */
   async applyBaseSnapshots() {
-    await this.snapshotManager.snapshot('3_accounts', addAccounts(3, this.logger), async ({ accountKeys }, { pxe }) => {
-      this.wallets = await Promise.all(
-        accountKeys.map(async ak => {
-          const account = await getSchnorrAccount(pxe, ak[0], ak[1], 1);
-          return account.getWallet();
-        }),
-      );
-      this.accounts = await pxe.getRegisteredAccounts();
-      this.wallets.forEach((w, i) => this.logger.verbose(`Wallet ${i} address: ${w.getAddress()}`));
-
-      this.pxe = pxe;
-    });
+    await this.snapshotManager.snapshot(
+      'accounts',
+      deployAccounts(this.numberOfAccounts, this.logger),
+      async ({ deployedAccounts }, { pxe }) => {
+        this.wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
+        this.accounts = await pxe.getRegisteredAccounts();
+        this.wallets.forEach((w, i) => this.logger.verbose(`Wallet ${i} address: ${w.getAddress()}`));
+        this.pxe = pxe;
+      },
+    );
 
     await this.snapshotManager.snapshot(
       'public_deploy',