@aztec/end-to-end 0.0.1-commit.1142ef1 → 0.0.1-commit.179ed20

package/src/e2e_epochs/epochs_test.ts

@@ -14,13 +14,15 @@ import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
 import { BlockNumber, CheckpointNumber, EpochNumber } from '@aztec/foundation/branded-types';
 import { SecretValue } from '@aztec/foundation/config';
 import { randomBytes } from '@aztec/foundation/crypto/random';
-import { withLogNameSuffix } from '@aztec/foundation/log';
+import { withLoggerBindings } from '@aztec/foundation/log/server';
 import { retryUntil } from '@aztec/foundation/retry';
 import { sleep } from '@aztec/foundation/sleep';
 import { SpamContract } from '@aztec/noir-test-contracts.js/Spam';
+import { TestContract } from '@aztec/noir-test-contracts.js/Test';
 import { getMockPubSubP2PServiceFactory } from '@aztec/p2p/test-helpers';
 import { ProverNode, type ProverNodeConfig, ProverNodePublisher } from '@aztec/prover-node';
 import type { TestProverNode } from '@aztec/prover-node/test';
+import type { PXEConfig } from '@aztec/pxe/config';
 import {
   type SequencerClient,
   type SequencerEvents,
@@ -49,7 +51,11 @@ export const WORLD_STATE_BLOCK_CHECK_INTERVAL = 50;
 export const ARCHIVER_POLL_INTERVAL = 50;
 export const DEFAULT_L1_BLOCK_TIME = process.env.CI ? 12 : 8;
 
-export type EpochsTestOpts = Partial<SetupOptions> & { numberOfAccounts?: number };
+export type EpochsTestOpts = Partial<SetupOptions> & {
+  numberOfAccounts?: number;
+  pxeOpts?: Partial<PXEConfig>;
+  aztecSlotDurationInL1Slots?: number;
+};
 
 export type TrackedSequencerEvent = {
   [K in keyof SequencerEvents]: Parameters<SequencerEvents[K]>[0] & {
@@ -94,7 +100,7 @@ export class EpochsTestContext {
       ? parseInt(process.env.L1_BLOCK_TIME)
       : DEFAULT_L1_BLOCK_TIME;
     const ethereumSlotDuration = opts.ethereumSlotDuration ?? envEthereumSlotDuration;
-    const aztecSlotDuration = opts.aztecSlotDuration ?? ethereumSlotDuration * 2;
+    const aztecSlotDuration = opts.aztecSlotDuration ?? (opts.aztecSlotDurationInL1Slots ?? 2) * ethereumSlotDuration;
     const aztecEpochDuration = opts.aztecEpochDuration ?? 6;
     const aztecProofSubmissionEpochs = opts.aztecProofSubmissionEpochs ?? 1;
     const l1PublishingTime = opts.l1PublishingTime ?? 1;
@@ -121,30 +127,36 @@ export class EpochsTestContext {
 
     // Set up system without any account nor protocol contracts
     // and with faster block times and shorter epochs.
-    const context = await setup(opts.numberOfAccounts ?? 0, {
-      automineL1Setup: true,
-      checkIntervalMs: 50,
-      archiverPollingIntervalMS: ARCHIVER_POLL_INTERVAL,
-      worldStateBlockCheckIntervalMS: WORLD_STATE_BLOCK_CHECK_INTERVAL,
-      aztecEpochDuration,
-      aztecSlotDuration,
-      ethereumSlotDuration,
-      aztecProofSubmissionEpochs,
-      aztecTargetCommitteeSize: opts.initialValidators?.length ?? 0,
-      minTxsPerBlock: 0,
-      realProofs: false,
-      startProverNode: true,
-      proverTestDelayMs: opts.proverTestDelayMs ?? 0,
-      // 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
-      // Use numeric EthAddress for deterministic prover id
-      proverId: EthAddress.fromNumber(1),
-      worldStateBlockHistory: WORLD_STATE_BLOCK_HISTORY,
-      exitDelaySeconds: DefaultL1ContractsConfig.exitDelaySeconds,
-      slasherFlavor: 'none',
-      l1PublishingTime,
-      ...opts,
-    });
+    const context = await setup(
+      opts.numberOfAccounts ?? 0,
+      {
+        automineL1Setup: true,
+        checkIntervalMs: 50,
+        archiverPollingIntervalMS: ARCHIVER_POLL_INTERVAL,
+        worldStateBlockCheckIntervalMS: WORLD_STATE_BLOCK_CHECK_INTERVAL,
+        aztecEpochDuration,
+        aztecSlotDuration,
+        ethereumSlotDuration,
+        aztecProofSubmissionEpochs,
+        aztecTargetCommitteeSize: opts.initialValidators?.length ?? 0,
+        minTxsPerBlock: 0,
+        realProofs: false,
+        startProverNode: true,
+        proverTestDelayMs: opts.proverTestDelayMs ?? 0,
+        // 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
+        // Use numeric EthAddress for deterministic prover id
+        proverId: EthAddress.fromNumber(1),
+        worldStateBlockHistory: WORLD_STATE_BLOCK_HISTORY,
+        exitDelaySeconds: DefaultL1ContractsConfig.exitDelaySeconds,
+        slasherFlavor: 'none',
+        l1PublishingTime,
+        ...opts,
+      },
+      // Use checkpointed chain tip for PXE by default to avoid issues with blocks being dropped due to pruned anchor blocks.
+      // Can be overridden via opts.pxeOpts.
+      { syncChainTip: 'checkpointed', ...opts.pxeOpts },
+    );
 
     this.context = context;
     this.proverNodes = context.proverNode ? [context.proverNode] : [];
@@ -199,19 +211,19 @@ export class EpochsTestContext {
   public async createProverNode(opts: { dontStart?: boolean } & Partial<ProverNodeConfig> = {}) {
     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, () =>
+    const proverIndex = this.proverNodes.length + 1;
+    const proverNode = await withLoggerBindings({ actor: `prover-${proverIndex}` }, () =>
       createAndSyncProverNode(
         proverNodePrivateKey,
         { ...this.context.config },
         {
           dataDirectory: join(this.context.config.dataDirectory!, randomBytes(8).toString('hex')),
-          proverId: EthAddress.fromNumber(parseInt(suffix, 10)),
+          proverId: EthAddress.fromNumber(proverIndex),
           dontStart: opts.dontStart,
           ...opts,
         },
         this.context.aztecNode,
-        undefined,
+        this.context.prefilledPublicData ?? [],
         { dateProvider: this.context.dateProvider },
       ),
     );
@@ -235,12 +247,13 @@ export class EpochsTestContext {
   private async createNode(
     opts: Partial<AztecNodeConfig> & { txDelayerMaxInclusionTimeIntoSlot?: number; dontStartSequencer?: boolean } = {},
   ) {
-    const suffix = (this.nodes.length + 1).toString();
+    const nodeIndex = this.nodes.length + 1;
+    const actorPrefix = opts.disableValidator ? 'node' : 'validator';
     const { mockGossipSubNetwork } = this.context;
     const resolvedConfig = { ...this.context.config, ...opts };
     const p2pEnabled = resolvedConfig.p2pEnabled || mockGossipSubNetwork !== undefined;
     const p2pIp = resolvedConfig.p2pIp ?? (p2pEnabled ? '127.0.0.1' : undefined);
-    const node = await withLogNameSuffix(suffix, () =>
+    const node = await withLoggerBindings({ actor: `${actorPrefix}-${nodeIndex}` }, () =>
       AztecNodeService.createAndSync(
         {
           ...resolvedConfig,
@@ -370,6 +383,19 @@ export class EpochsTestContext {
     return SpamContract.at(instance.address, wallet);
   }
 
+  /** Registers the TestContract on the given wallet. */
+  public async registerTestContract(wallet: Wallet, salt = Fr.ZERO) {
+    const instance = await getContractInstanceFromInstantiationParams(TestContract.artifact, {
+      constructorArgs: [],
+      constructorArtifact: undefined,
+      salt,
+      publicKeys: undefined,
+      deployer: undefined,
+    });
+    await wallet.registerContract(instance, TestContract.artifact);
+    return TestContract.at(instance.address, wallet);
+  }
+
   /** Creates an L1 client using a fresh account with funds from anvil, with a tx delayer already set up. */
   public async createL1Client() {
     const { client, delayer } = withDelayer(

package/src/e2e_fees/bridging_race.notest.ts

@@ -26,11 +26,8 @@ describe('e2e_fees bridging_race', () => {
   });
 
   beforeAll(async () => {
-    await t.applyInitialAccountsSnapshot();
-    await t.applyPublicDeployAccountsSnapshot();
-    await t.applySetupFeeJuiceSnapshot();
-
-    ({ wallet, logger } = await t.setup());
+    await t.setup();
+    ({ wallet, logger } = t);
   });
 
   afterAll(async () => {
@@ -70,10 +67,7 @@ describe('e2e_fees bridging_race', () => {
     // Yes, we need to REFACTOR it at some point
     const claim = await t.feeJuiceBridgeTestHarness.prepareTokensOnL1(bobsAddress);
     const { claimSecret: secret, messageLeafIndex: index } = claim;
-    await t.feeJuiceContract.methods
-      .claim(bobsAddress, claim.claimAmount, secret, index)
-      .send({ from: bobsAddress })
-      .wait();
+    await t.feeJuiceContract.methods.claim(bobsAddress, claim.claimAmount, secret, index).send({ from: bobsAddress });
     const [balance] = await t.getGasBalanceFn(bobsAddress);
     expect(balance).toEqual(claim.claimAmount);
   });

package/src/e2e_fees/fees_test.ts

@@ -26,25 +26,19 @@ import { getContract } from 'viem';
 
 import { MNEMONIC } from '../fixtures/fixtures.js';
 import {
-  type ISnapshotManager,
-  type SubsystemsContext,
-  createSnapshotManager,
+  type EndToEndContext,
+  type SetupOptions,
   deployAccounts,
-} from '../fixtures/snapshot_manager.js';
+  publicDeployAccounts,
+  setup,
+  teardown,
+} from '../fixtures/setup.js';
 import { mintTokensToPrivate } from '../fixtures/token_utils.js';
-import {
-  type BalancesFn,
-  type SetupOptions,
-  ensureAccountContractsPublished,
-  getBalancesFn,
-  setupSponsoredFPC,
-} from '../fixtures/utils.js';
+import { type BalancesFn, getBalancesFn, setupSponsoredFPC } from '../fixtures/utils.js';
 import { FeeJuicePortalTestingHarnessFactory, type GasBridgingTestHarness } from '../shared/gas_portal_test_harness.js';
 
-const { E2E_DATA_PATH: dataPath } = process.env;
-
 /**
- * Test fixture for testing fees. Provides the following snapshots:
+ * Test fixture for testing fees. Provides the following setup steps:
  * InitialAccounts: Initializes 3 Schnorr account contracts.
  * PublicDeployAccounts: Deploys the accounts publicly.
  * DeployFeeJuice: Deploys the Fee Juice contract.
@@ -54,8 +48,8 @@ const { E2E_DATA_PATH: dataPath } = process.env;
  * SetupSubscription: Deploys a counter contract and a subscription contract, and mints Fee Juice to the subscription contract.
  */
 export class FeesTest {
-  private snapshotManager: ISnapshotManager;
   private accounts: AztecAddress[] = [];
+  public context!: EndToEndContext;
 
   public logger: Logger;
   public aztecNode!: AztecNode;
@@ -82,7 +76,6 @@ export class FeesTest {
   public subscriptionContract!: AppSubscriptionContract;
   public feeJuiceBridgeTestHarness!: GasBridgingTestHarness;
 
-  public context!: SubsystemsContext;
   public chainMonitor!: ChainMonitor;
 
   public getCoinbaseBalance!: () => Promise<bigint>;
@@ -99,7 +92,7 @@ export class FeesTest {
   constructor(
     testName: string,
     private numberOfAccounts = 3,
-    setupOptions: Partial<SetupOptions & DeployAztecL1ContractsArgs> = {},
+    private setupOptions: Partial<SetupOptions & DeployAztecL1ContractsArgs> = {},
   ) {
     if (!numberOfAccounts) {
       throw new Error('There must be at least 1 initial account.');
@@ -107,30 +100,33 @@ export class FeesTest {
     setupOptions.coinbase ??= EthAddress.random();
     this.coinbase = setupOptions.coinbase!;
     this.logger = createLogger(`e2e:e2e_fees:${testName}`);
-    this.snapshotManager = createSnapshotManager(
-      `e2e_fees/${testName}-${numberOfAccounts}`,
-      dataPath,
-      { startProverNode: true, ...setupOptions },
-      { ...setupOptions },
-    );
   }
 
   async setup() {
-    const context = await this.snapshotManager.setup();
+    this.logger.verbose('Setting up fresh context...');
+    this.context = await setup(0, {
+      startProverNode: true,
+      ...this.setupOptions,
+      fundSponsoredFPC: true,
+      skipAccountDeployment: true,
+      l1ContractsArgs: { ...this.setupOptions },
+    });
 
-    this.rollupContract = RollupContract.getFromConfig(context.aztecNodeConfig);
-    this.chainMonitor = new ChainMonitor(this.rollupContract, context.dateProvider, this.logger, 200).start();
+    this.rollupContract = RollupContract.getFromConfig(this.context.config);
+    this.chainMonitor = new ChainMonitor(this.rollupContract, this.context.dateProvider!, this.logger, 200).start();
+
+    await this.applyBaseSetup();
 
     return this;
   }
 
   async teardown() {
     await this.chainMonitor.stop();
-    await this.snapshotManager.teardown();
+    await teardown(this.context);
   }
 
   setIsMarkingAsProven(b: boolean) {
-    this.context.watcher.setIsMarkingAsProven(b);
+    this.context.watcher!.setIsMarkingAsProven(b);
   }
 
   async catchUpProvenChain() {
@@ -156,10 +152,7 @@ export class FeesTest {
   async mintAndBridgeFeeJuice(minter: AztecAddress, recipient: AztecAddress) {
     const claim = await this.feeJuiceBridgeTestHarness.prepareTokensOnL1(recipient);
     const { claimSecret: secret, messageLeafIndex: index } = claim;
-    await this.feeJuiceContract.methods
-      .claim(recipient, claim.claimAmount, secret, index)
-      .send({ from: minter })
-      .wait();
+    await this.feeJuiceContract.methods.claim(recipient, claim.claimAmount, secret, index).send({ from: minter });
   }
 
   /** Alice mints bananaCoin tokens privately to the target address and redeems them. */
@@ -176,210 +169,171 @@ export class FeesTest {
     expect(balanceAfter).toEqual(balanceBefore + amount);
   }
 
-  public async applyBaseSnapshots() {
-    await this.applyInitialAccountsSnapshot();
-    await this.applyPublicDeployAccountsSnapshot();
-    await this.applySetupFeeJuiceSnapshot();
-    await this.applyDeployBananaTokenSnapshot();
+  public async applyBaseSetup() {
+    await this.applyInitialAccounts();
+    await this.applyPublicDeployAccounts();
+    await this.applySetupFeeJuice();
+    await this.applyDeployBananaToken();
   }
 
-  async applyInitialAccountsSnapshot() {
-    await this.snapshotManager.snapshot(
-      'initial_accounts',
-      deployAccounts(this.numberOfAccounts, this.logger),
-      async ({ deployedAccounts }, { wallet, aztecNode, cheatCodes }) => {
-        this.wallet = wallet;
-        this.aztecNode = aztecNode;
-        this.aztecNodeAdmin = aztecNode;
-        this.gasSettings = GasSettings.default({ maxFeesPerGas: (await this.aztecNode.getCurrentMinFees()).mul(2) });
-        this.cheatCodes = cheatCodes;
-        this.accounts = deployedAccounts.map(a => a.address);
-        this.accounts.forEach((a, i) => this.logger.verbose(`Account ${i} address: ${a}`));
-        [this.aliceAddress, this.bobAddress, this.sequencerAddress] = this.accounts.slice(0, 3);
-
-        // 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 = FeeJuiceContract.at(canonicalFeeJuice.address, this.wallet);
-      },
-    );
+  async applyInitialAccounts() {
+    this.logger.info('Applying initial accounts setup');
+
+    const { deployedAccounts } = await deployAccounts(
+      this.numberOfAccounts,
+      this.logger,
+    )({
+      wallet: this.context.wallet,
+      initialFundedAccounts: this.context.initialFundedAccounts,
+    });
+
+    this.wallet = this.context.wallet;
+    this.aztecNode = this.context.aztecNodeService!;
+    this.aztecNodeAdmin = this.context.aztecNodeService!;
+    this.gasSettings = GasSettings.default({ maxFeesPerGas: (await this.aztecNode.getCurrentMinFees()).mul(2) });
+    this.cheatCodes = this.context.cheatCodes;
+    this.accounts = deployedAccounts.map(a => a.address);
+    this.accounts.forEach((a, i) => this.logger.verbose(`Account ${i} address: ${a}`));
+    [this.aliceAddress, this.bobAddress, this.sequencerAddress] = this.accounts.slice(0, 3);
+
+    // 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 = FeeJuiceContract.at(canonicalFeeJuice.address, this.wallet);
   }
 
-  async applyPublicDeployAccountsSnapshot() {
-    await this.snapshotManager.snapshot('public_deploy_accounts', () =>
-      ensureAccountContractsPublished(this.wallet, this.accounts),
-    );
+  async applyPublicDeployAccounts() {
+    this.logger.info('Applying public deploy accounts setup');
+    await publicDeployAccounts(this.wallet, this.accounts);
   }
 
-  async applySetupFeeJuiceSnapshot() {
-    await this.snapshotManager.snapshot(
-      'setup_fee_juice',
-      async () => {},
-      async (_data, context) => {
-        this.context = context;
-
-        this.feeJuiceContract = FeeJuiceContract.at(ProtocolContractAddress.FeeJuice, this.wallet);
-
-        this.getGasBalanceFn = getBalancesFn(
-          '⛽',
-          this.feeJuiceContract.methods.balance_of_public,
-          this.aliceAddress,
-          this.logger,
-        );
-
-        this.feeJuiceBridgeTestHarness = await FeeJuicePortalTestingHarnessFactory.create({
-          aztecNode: context.aztecNode,
-          aztecNodeAdmin: context.aztecNode,
-          l1Client: context.deployL1ContractsValues.l1Client,
-          wallet: this.wallet,
-          logger: this.logger,
-        });
-      },
+  async applySetupFeeJuice() {
+    this.logger.info('Applying fee juice setup');
+
+    this.feeJuiceContract = FeeJuiceContract.at(ProtocolContractAddress.FeeJuice, this.wallet);
+
+    this.getGasBalanceFn = getBalancesFn(
+      '⛽',
+      this.feeJuiceContract.methods.balance_of_public,
+      this.aliceAddress,
+      this.logger,
     );
+
+    this.feeJuiceBridgeTestHarness = await FeeJuicePortalTestingHarnessFactory.create({
+      aztecNode: this.context.aztecNodeService!,
+      aztecNodeAdmin: this.context.aztecNodeService!,
+      l1Client: this.context.deployL1ContractsValues.l1Client,
+      wallet: this.wallet,
+      logger: this.logger,
+    });
   }
 
-  async applyDeployBananaTokenSnapshot() {
-    await this.snapshotManager.snapshot(
-      'deploy_banana_token',
-      async () => {
-        const bananaCoin = await BananaCoin.deploy(this.wallet, this.aliceAddress, 'BC', 'BC', 18n)
-          .send({ from: this.aliceAddress })
-          .deployed();
-        this.logger.info(`BananaCoin deployed at ${bananaCoin.address}`);
-        return { bananaCoinAddress: bananaCoin.address };
-      },
-      ({ bananaCoinAddress }) => {
-        this.bananaCoin = BananaCoin.at(bananaCoinAddress, this.wallet);
-        const logger = this.logger;
-        this.getBananaPublicBalanceFn = getBalancesFn(
-          '🍌.public',
-          this.bananaCoin.methods.balance_of_public,
-          this.aliceAddress,
-          logger,
-        );
-        this.getBananaPrivateBalanceFn = getBalancesFn(
-          '🍌.private',
-          this.bananaCoin.methods.balance_of_private,
-          this.aliceAddress,
-          logger,
-        );
-        return Promise.resolve();
-      },
+  async applyDeployBananaToken() {
+    this.logger.info('Applying deploy banana token setup');
+
+    const bananaCoin = await BananaCoin.deploy(this.wallet, this.aliceAddress, 'BC', 'BC', 18n).send({
+      from: this.aliceAddress,
+    });
+    this.logger.info(`BananaCoin deployed at ${bananaCoin.address}`);
+
+    this.bananaCoin = bananaCoin;
+    this.getBananaPublicBalanceFn = getBalancesFn(
+      '🍌.public',
+      this.bananaCoin.methods.balance_of_public,
+      this.aliceAddress,
+      this.logger,
+    );
+    this.getBananaPrivateBalanceFn = getBalancesFn(
+      '🍌.private',
+      this.bananaCoin.methods.balance_of_private,
+      this.aliceAddress,
+      this.logger,
     );
   }
 
-  public async applyFPCSetupSnapshot() {
-    await this.snapshotManager.snapshot(
-      'fpc_setup',
-      async context => {
-        const feeJuiceContract = this.feeJuiceBridgeTestHarness.feeJuice;
-        expect((await context.wallet.getContractMetadata(feeJuiceContract.address)).isContractPublished).toBe(true);
-
-        const bananaCoin = this.bananaCoin;
-        const bananaFPC = await FPCContract.deploy(this.wallet, bananaCoin.address, this.fpcAdmin)
-          .send({ from: this.aliceAddress })
-          .deployed();
-
-        this.logger.info(`BananaPay deployed at ${bananaFPC.address}`);
-
-        await this.feeJuiceBridgeTestHarness.bridgeFromL1ToL2(bananaFPC.address, this.aliceAddress);
-
-        return {
-          bananaFPCAddress: bananaFPC.address,
-          feeJuiceAddress: feeJuiceContract.address,
-          l1FeeJuiceAddress: this.feeJuiceBridgeTestHarness.l1FeeJuiceAddress,
-          rollupAddress: context.deployL1ContractsValues.l1ContractAddresses.rollupAddress,
-        };
-      },
-      (data, context) => {
-        const bananaFPC = FPCContract.at(data.bananaFPCAddress, this.wallet);
-        this.bananaFPC = bananaFPC;
-
-        this.getCoinbaseBalance = async () => {
-          const l1Client = createExtendedL1Client(context.aztecNodeConfig.l1RpcUrls, MNEMONIC);
-          const gasL1 = getContract({
-            address: data.l1FeeJuiceAddress.toString(),
-            abi: TestERC20Abi,
-            client: l1Client,
-          });
-          return await gasL1.read.balanceOf([this.coinbase.toString()]);
-        };
-
-        this.getCoinbaseSequencerRewards = async () => {
-          return await this.rollupContract.getSequencerRewards(this.coinbase);
-        };
-
-        this.getProverFee = async (blockNumber: BlockNumber) => {
-          const block = await this.aztecNode.getBlock(blockNumber);
-
-          // @todo @lherskind As we deal with #13601
-          // Right now the value is from `FeeLib.sol`
-          const L1_GAS_PER_EPOCH_VERIFIED = 1000000n;
-
-          // We round up
-          const mulDiv = (a: bigint, b: bigint, c: bigint) => (a * b) / c + ((a * b) % c > 0n ? 1n : 0n);
-
-          const { baseFee } = await this.rollupContract.getL1FeesAt(block!.header.globalVariables.timestamp);
-          const proverCost =
-            mulDiv(
-              mulDiv(L1_GAS_PER_EPOCH_VERIFIED, baseFee, BigInt(await this.rollupContract.getEpochDuration())),
-              1n,
-              await this.rollupContract.getManaTarget(),
-            ) + (await this.rollupContract.getProvingCostPerMana());
-
-          const price = await this.rollupContract.getFeeAssetPerEth();
-
-          const mana = block!.header.totalManaUsed.toBigInt();
-          return mulDiv(mana * proverCost, price, 10n ** 9n);
-        };
-        return Promise.resolve();
-      },
-    );
+  public async applyFPCSetup() {
+    this.logger.info('Applying FPC setup');
+
+    const feeJuiceContract = this.feeJuiceBridgeTestHarness.feeJuice;
+    expect((await this.wallet.getContractMetadata(feeJuiceContract.address)).isContractPublished).toBe(true);
+
+    const bananaCoin = this.bananaCoin;
+    const bananaFPC = await FPCContract.deploy(this.wallet, bananaCoin.address, this.fpcAdmin).send({
+      from: this.aliceAddress,
+    });
+
+    this.logger.info(`BananaPay deployed at ${bananaFPC.address}`);
+
+    await this.feeJuiceBridgeTestHarness.bridgeFromL1ToL2(bananaFPC.address, this.aliceAddress);
+
+    this.bananaFPC = bananaFPC;
+
+    const l1FeeJuiceAddress = this.feeJuiceBridgeTestHarness.l1FeeJuiceAddress;
+
+    this.getCoinbaseBalance = async () => {
+      const l1Client = createExtendedL1Client(this.context.config.l1RpcUrls, MNEMONIC);
+      const gasL1 = getContract({
+        address: l1FeeJuiceAddress.toString(),
+        abi: TestERC20Abi,
+        client: l1Client,
+      });
+      return await gasL1.read.balanceOf([this.coinbase.toString()]);
+    };
+
+    this.getCoinbaseSequencerRewards = async () => {
+      return await this.rollupContract.getSequencerRewards(this.coinbase);
+    };
+
+    this.getProverFee = async (blockNumber: BlockNumber) => {
+      const block = await this.aztecNode.getBlock(blockNumber);
+
+      // @todo @lherskind As we deal with #13601
+      // Right now the value is from `FeeLib.sol`
+      const L1_GAS_PER_EPOCH_VERIFIED = 1000000n;
+
+      // We round up
+      const mulDiv = (a: bigint, b: bigint, c: bigint) => (a * b) / c + ((a * b) % c > 0n ? 1n : 0n);
+
+      const { baseFee } = await this.rollupContract.getL1FeesAt(block!.header.globalVariables.timestamp);
+      const proverCost =
+        mulDiv(
+          mulDiv(L1_GAS_PER_EPOCH_VERIFIED, baseFee, BigInt(await this.rollupContract.getEpochDuration())),
+          1n,
+          await this.rollupContract.getManaTarget(),
+        ) + (await this.rollupContract.getProvingCostPerMana());
+
+      const price = await this.rollupContract.getEthPerFeeAsset();
+
+      const mana = block!.header.totalManaUsed.toBigInt();
+      return mulDiv(mana * proverCost, 10n ** 12n, price);
+    };
   }
 
-  public async applySponsoredFPCSetupSnapshot() {
-    await this.snapshotManager.snapshot(
-      'sponsored_fpc_setup',
-      async context => {
-        const feeJuiceContract = this.feeJuiceBridgeTestHarness.feeJuice;
-        expect((await context.wallet.getContractMetadata(feeJuiceContract.address)).isContractPublished).toBe(true);
-
-        const sponsoredFPC = await setupSponsoredFPC(this.wallet);
-        this.logger.info(`SponsoredFPC at ${sponsoredFPC.address}`);
-
-        return {
-          sponsoredFPCAddress: sponsoredFPC.address,
-        };
-      },
-      data => {
-        this.sponsoredFPC = SponsoredFPCContract.at(data.sponsoredFPCAddress, this.wallet);
-        return Promise.resolve();
-      },
-    );
+  public async applySponsoredFPCSetup() {
+    this.logger.info('Applying sponsored FPC setup');
+
+    const feeJuiceContract = this.feeJuiceBridgeTestHarness.feeJuice;
+    expect((await this.wallet.getContractMetadata(feeJuiceContract.address)).isContractPublished).toBe(true);
+
+    const sponsoredFPCInstance = await setupSponsoredFPC(this.wallet);
+    this.logger.info(`SponsoredFPC at ${sponsoredFPCInstance.address}`);
+
+    this.sponsoredFPC = SponsoredFPCContract.at(sponsoredFPCInstance.address, this.wallet);
   }
 
   public async applyFundAliceWithBananas() {
-    await this.snapshotManager.snapshot(
-      'fund_alice',
-      async () => {
-        await this.mintPrivateBananas(this.ALICE_INITIAL_BANANAS, this.aliceAddress);
-        await this.bananaCoin.methods
-          .mint_to_public(this.aliceAddress, this.ALICE_INITIAL_BANANAS)
-          .send({ from: this.aliceAddress })
-          .wait();
-      },
-      () => Promise.resolve(),
-    );
+    this.logger.info('Applying fund Alice with bananas setup');
+
+    await this.mintPrivateBananas(this.ALICE_INITIAL_BANANAS, this.aliceAddress);
+    await this.bananaCoin.methods
+      .mint_to_public(this.aliceAddress, this.ALICE_INITIAL_BANANAS)
+      .send({ from: this.aliceAddress });
   }
 
   public async applyFundAliceWithPrivateBananas() {
-    await this.snapshotManager.snapshot(
-      'fund_alice_with_private_bananas',
-      async () => {
-        await this.mintPrivateBananas(this.ALICE_INITIAL_BANANAS, this.aliceAddress);
-      },
-      () => Promise.resolve(),
-    );
+    this.logger.info('Applying fund Alice with private bananas setup');
+
+    await this.mintPrivateBananas(this.ALICE_INITIAL_BANANAS, this.aliceAddress);
   }
 }