@aztec/end-to-end 0.0.1-commit.24de95ac → 0.0.1-commit.2606882

package/src/e2e_p2p/p2p_network.ts

@@ -1,21 +1,17 @@
-import type { InitialAccountData } from '@aztec/accounts/testing';
+import { type InitialAccountData, generateSchnorrAccounts } from '@aztec/accounts/testing';
 import type { AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
+import { getAccountContractAddress } from '@aztec/aztec.js/account';
 import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
 import { Fr } from '@aztec/aztec.js/fields';
-import {
-  type EmpireSlashingProposerContract,
-  type ExtendedViemWalletClient,
-  GSEContract,
-  MultiAdderArtifact,
-  type Operator,
-  RollupContract,
-  type TallySlashingProposerContract,
-  type ViemClient,
-  createL1TxUtilsFromViemWallet,
-  deployL1Contract,
-  getL1ContractsConfigEnvVars,
-} from '@aztec/ethereum';
+import { getL1ContractsConfigEnvVars } from '@aztec/ethereum/config';
+import { GSEContract, RollupContract, type SlashingProposerContract } from '@aztec/ethereum/contracts';
+import type { Operator } from '@aztec/ethereum/deploy-aztec-l1-contracts';
+import { deployL1Contract } from '@aztec/ethereum/deploy-l1-contract';
+import { MultiAdderArtifact } from '@aztec/ethereum/l1-artifacts';
+import { createL1TxUtils } from '@aztec/ethereum/l1-tx-utils';
 import { ChainMonitor } from '@aztec/ethereum/test';
+import type { ExtendedViemWalletClient, ViemClient } from '@aztec/ethereum/types';
+import { EpochNumber } from '@aztec/foundation/branded-types';
 import { SecretValue } from '@aztec/foundation/config';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
@@ -24,29 +20,34 @@ import { SpamContract } from '@aztec/noir-test-contracts.js/Spam';
 import type { BootstrapNode } from '@aztec/p2p/bootstrap';
 import { createBootstrapNodeFromPrivateKey, getBootstrapNodeEnr } from '@aztec/p2p/test-helpers';
 import { tryStop } from '@aztec/stdlib/interfaces/server';
-import { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
-import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
+import { TopicType } from '@aztec/stdlib/p2p';
+import type { GenesisData } from '@aztec/stdlib/world-state';
 import { ZkPassportProofParams } from '@aztec/stdlib/zkpassport';
-import type { TestWallet } from '@aztec/test-wallet/server';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
 import getPort from 'get-port';
 import { type GetContractReturnType, getAddress, getContract } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 
+import {
+  SCHNORR_HARDCODED_PRIVATE_KEY,
+  SchnorrHardcodedKeyAccountContract,
+} from '../fixtures/schnorr_hardcoded_account_contract.js';
+import {
+  type EndToEndContext,
+  type SetupOptions,
+  getPrivateKeyFromIndex,
+  getSponsoredFPCAddress,
+  setup,
+  teardown,
+} from '../fixtures/setup.js';
 import {
   ATTESTER_PRIVATE_KEYS_START_INDEX,
   createValidatorConfig,
   generatePrivateKeys,
 } from '../fixtures/setup_p2p_test.js';
-import {
-  type ISnapshotManager,
-  type SubsystemsContext,
-  createSnapshotManager,
-  deployAccounts,
-} from '../fixtures/snapshot_manager.js';
-import { type SetupOptions, getPrivateKeyFromIndex, getSponsoredFPCAddress } from '../fixtures/utils.js';
 import { getEndToEndTestTelemetryClient } from '../fixtures/with_telemetry_utils.js';
+import type { TestWallet } from '../test-wallet/test_wallet.js';
 
 // Use a fixed bootstrap node private key so that we can re-use the same snapshot and the nodes can find each other
 const BOOTSTRAP_NODE_PRIVATE_KEY = '080212208f988fc0899e4a73a5aee4d271a5f20670603a756ad8d84f2c94263a6427c591';
@@ -56,25 +57,25 @@ export const WAIT_FOR_TX_TIMEOUT = l1ContractsConfig.aztecSlotDuration * 3;
 export const SHORTENED_BLOCK_TIME_CONFIG_NO_PRUNES = {
   aztecSlotDuration: 12,
   ethereumSlotDuration: 4,
-  aztecProofSubmissionWindow: 640,
+  aztecProofSubmissionEpochs: 640,
 };
 
 export class P2PNetworkTest {
-  private snapshotManager: ISnapshotManager;
+  public context!: EndToEndContext;
   public baseAccountPrivateKey: `0x${string}`;
   public baseAccount;
 
   public logger: Logger;
   public monitor!: ChainMonitor;
 
-  public ctx!: SubsystemsContext;
+  public ctx!: EndToEndContext;
   public attesterPrivateKeys: `0x${string}`[] = [];
   public attesterPublicKeys: string[] = [];
   public peerIdPrivateKeys: string[] = [];
   public validators: Operator[] = [];
 
-  public deployedAccounts: InitialAccountData[] = [];
-  public prefilledPublicData: PublicDataTreeLeaf[] = [];
+  public hardcodedAccountData!: InitialAccountData;
+  public genesis: GenesisData | undefined;
 
   // The re-execution test needs a wallet and a spam contract
   public wallet?: TestWallet;
@@ -83,6 +84,10 @@ export class P2PNetworkTest {
 
   public bootstrapNode?: BootstrapNode;
 
+  // Store setup options for use in setup()
+  private setupOptions: SetupOptions;
+  private deployL1ContractsArgs: any;
+
   constructor(
     public readonly testName: string,
     public bootstrapNodeEnr: string,
@@ -93,7 +98,6 @@ export class P2PNetworkTest {
     // If set enable metrics collection
     private metricsPort?: number,
     startProverNode?: boolean,
-    mockZkPassportVerifier?: boolean,
   ) {
     this.logger = createLogger(`e2e:e2e_p2p:${testName}`);
 
@@ -108,45 +112,41 @@ export class P2PNetworkTest {
 
     const zkPassportParams = ZkPassportProofParams.random();
 
-    this.snapshotManager = createSnapshotManager(
-      `e2e_p2p_network/${testName}`,
-      process.env.E2E_DATA_PATH,
-      {
-        ...initialValidatorConfig,
-        ethereumSlotDuration: initialValidatorConfig.ethereumSlotDuration ?? l1ContractsConfig.ethereumSlotDuration,
-        aztecEpochDuration: initialValidatorConfig.aztecEpochDuration ?? l1ContractsConfig.aztecEpochDuration,
-        aztecSlotDuration: initialValidatorConfig.aztecSlotDuration ?? l1ContractsConfig.aztecSlotDuration,
-        aztecProofSubmissionEpochs:
-          initialValidatorConfig.aztecProofSubmissionEpochs ?? l1ContractsConfig.aztecProofSubmissionEpochs,
-        slashingRoundSizeInEpochs:
-          initialValidatorConfig.slashingRoundSizeInEpochs ?? l1ContractsConfig.slashingRoundSizeInEpochs,
-        slasherFlavor: initialValidatorConfig.slasherFlavor ?? 'tally',
-        aztecTargetCommitteeSize: numberOfValidators,
-        salt: 420,
-        metricsPort: metricsPort,
-        numberOfInitialFundedAccounts: 2,
-        startProverNode,
-      },
-      {
-        ...initialValidatorConfig,
-        aztecEpochDuration: initialValidatorConfig.aztecEpochDuration ?? l1ContractsConfig.aztecEpochDuration,
-        slashingRoundSizeInEpochs:
-          initialValidatorConfig.slashingRoundSizeInEpochs ?? l1ContractsConfig.slashingRoundSizeInEpochs,
-        slasherFlavor: initialValidatorConfig.slasherFlavor ?? 'tally',
-
-        ethereumSlotDuration: initialValidatorConfig.ethereumSlotDuration ?? l1ContractsConfig.ethereumSlotDuration,
-        aztecSlotDuration: initialValidatorConfig.aztecSlotDuration ?? l1ContractsConfig.aztecSlotDuration,
-        aztecProofSubmissionEpochs:
-          initialValidatorConfig.aztecProofSubmissionEpochs ?? l1ContractsConfig.aztecProofSubmissionEpochs,
-        aztecTargetCommitteeSize: numberOfValidators,
-        initialValidators: [],
-        zkPassportArgs: {
-          mockZkPassportVerifier,
-          zkPassportDomain: zkPassportParams.domain,
-          zkPassportScope: zkPassportParams.scope,
-        },
+    // Store setup options for later use
+    this.setupOptions = {
+      ...initialValidatorConfig,
+      ethereumSlotDuration: initialValidatorConfig.ethereumSlotDuration ?? l1ContractsConfig.ethereumSlotDuration,
+      aztecEpochDuration: initialValidatorConfig.aztecEpochDuration ?? l1ContractsConfig.aztecEpochDuration,
+      aztecSlotDuration: initialValidatorConfig.aztecSlotDuration ?? l1ContractsConfig.aztecSlotDuration,
+      aztecProofSubmissionEpochs:
+        initialValidatorConfig.aztecProofSubmissionEpochs ?? l1ContractsConfig.aztecProofSubmissionEpochs,
+      slashingRoundSizeInEpochs:
+        initialValidatorConfig.slashingRoundSizeInEpochs ?? l1ContractsConfig.slashingRoundSizeInEpochs,
+      slasherEnabled: initialValidatorConfig.slasherEnabled ?? true,
+      aztecTargetCommitteeSize: numberOfValidators,
+      metricsPort: metricsPort,
+      numberOfInitialFundedAccounts: 2,
+      startProverNode,
+    };
+
+    this.deployL1ContractsArgs = {
+      ...initialValidatorConfig,
+      aztecEpochDuration: initialValidatorConfig.aztecEpochDuration ?? l1ContractsConfig.aztecEpochDuration,
+      slashingRoundSizeInEpochs:
+        initialValidatorConfig.slashingRoundSizeInEpochs ?? l1ContractsConfig.slashingRoundSizeInEpochs,
+      slasherEnabled: initialValidatorConfig.slasherEnabled ?? true,
+
+      ethereumSlotDuration: initialValidatorConfig.ethereumSlotDuration ?? l1ContractsConfig.ethereumSlotDuration,
+      aztecSlotDuration: initialValidatorConfig.aztecSlotDuration ?? l1ContractsConfig.aztecSlotDuration,
+      aztecProofSubmissionEpochs:
+        initialValidatorConfig.aztecProofSubmissionEpochs ?? l1ContractsConfig.aztecProofSubmissionEpochs,
+      aztecTargetCommitteeSize: numberOfValidators,
+      initialValidators: [],
+      zkPassportArgs: {
+        zkPassportDomain: zkPassportParams.domain,
+        zkPassportScope: zkPassportParams.scope,
       },
-    );
+    };
   }
 
   static async create({
@@ -157,7 +157,6 @@ export class P2PNetworkTest {
     metricsPort,
     initialConfig,
     startProverNode,
-    mockZkPassportVerifier,
   }: {
     testName: string;
     numberOfNodes: number;
@@ -166,7 +165,6 @@ export class P2PNetworkTest {
     metricsPort?: number;
     initialConfig?: SetupOptions;
     startProverNode?: boolean;
-    mockZkPassportVerifier?: boolean;
   }) {
     const port = basePort || (await getPort());
 
@@ -187,29 +185,27 @@ export class P2PNetworkTest {
       numberOfNodes,
       metricsPort,
       startProverNode,
-      mockZkPassportVerifier,
     );
   }
 
   get fundedAccount() {
-    if (!this.deployedAccounts[0]) {
-      throw new Error('Call snapshot t.setupAccount to create a funded account.');
+    if (!this.hardcodedAccountData) {
+      throw new Error('Call setup to initialize the hardcoded account.');
     }
-    return this.deployedAccounts[0];
+    return this.hardcodedAccountData;
   }
 
   async addBootstrapNode() {
-    await this.snapshotManager.snapshot('add-bootstrap-node', async ({ aztecNodeConfig }) => {
-      const telemetry = getEndToEndTestTelemetryClient(this.metricsPort);
-      this.bootstrapNode = await createBootstrapNodeFromPrivateKey(
-        BOOTSTRAP_NODE_PRIVATE_KEY,
-        this.bootNodePort,
-        telemetry,
-        aztecNodeConfig,
-      );
-      // Overwrite enr with updated info
-      this.bootstrapNodeEnr = this.bootstrapNode.getENR().encodeTxt();
-    });
+    this.logger.info('Adding bootstrap node');
+    const telemetry = await getEndToEndTestTelemetryClient(this.metricsPort);
+    this.bootstrapNode = await createBootstrapNodeFromPrivateKey(
+      BOOTSTRAP_NODE_PRIVATE_KEY,
+      this.bootNodePort,
+      telemetry,
+      this.context.config,
+    );
+    // Overwrite enr with updated info
+    this.bootstrapNodeEnr = this.bootstrapNode.getENR().encodeTxt();
   }
 
   getValidators() {
@@ -230,125 +226,120 @@ export class P2PNetworkTest {
     return { validators };
   }
 
-  async applyBaseSnapshots() {
+  async applyBaseSetup() {
     await this.addBootstrapNode();
-    await this.snapshotManager.snapshot('add-validators', async ({ deployL1ContractsValues, cheatCodes }) => {
-      const rollup = getContract({
-        address: deployL1ContractsValues.l1ContractAddresses.rollupAddress.toString(),
-        abi: RollupAbi,
-        client: deployL1ContractsValues.l1Client,
-      });
 
-      this.logger.info(`Adding ${this.numberOfValidators} validators`);
+    this.logger.info('Adding validators');
+    const rollup = getContract({
+      address: this.context.deployL1ContractsValues.l1ContractAddresses.rollupAddress.toString(),
+      abi: RollupAbi,
+      client: this.context.deployL1ContractsValues.l1Client,
+    });
 
-      const stakingAsset = getContract({
-        address: deployL1ContractsValues.l1ContractAddresses.stakingAssetAddress.toString(),
-        abi: TestERC20Abi,
-        client: deployL1ContractsValues.l1Client,
-      });
+    this.logger.info(`Adding ${this.numberOfValidators} validators`);
 
-      const { address: multiAdderAddress } = await deployL1Contract(
-        deployL1ContractsValues.l1Client,
-        MultiAdderArtifact.contractAbi,
-        MultiAdderArtifact.contractBytecode,
-        [rollup.address, deployL1ContractsValues.l1Client.account.address],
-      );
+    const stakingAsset = getContract({
+      address: this.context.deployL1ContractsValues.l1ContractAddresses.stakingAssetAddress.toString(),
+      abi: TestERC20Abi,
+      client: this.context.deployL1ContractsValues.l1Client,
+    });
 
-      const multiAdder = getContract({
-        address: multiAdderAddress.toString(),
-        abi: MultiAdderArtifact.contractAbi,
-        client: deployL1ContractsValues.l1Client,
-      });
+    const { address: multiAdderAddress } = await deployL1Contract(
+      this.context.deployL1ContractsValues.l1Client,
+      MultiAdderArtifact.contractAbi,
+      MultiAdderArtifact.contractBytecode,
+      [rollup.address, this.context.deployL1ContractsValues.l1Client.account.address],
+    );
 
-      const stakeNeeded = (await rollup.read.getActivationThreshold()) * BigInt(this.numberOfValidators);
-      await Promise.all(
-        [await stakingAsset.write.mint([multiAdder.address, stakeNeeded], {} as any)].map(txHash =>
-          deployL1ContractsValues.l1Client.waitForTransactionReceipt({ hash: txHash }),
-        ),
-      );
+    const multiAdder = getContract({
+      address: multiAdderAddress.toString(),
+      abi: MultiAdderArtifact.contractAbi,
+      client: this.context.deployL1ContractsValues.l1Client,
+    });
 
-      const { validators } = this.getValidators();
-      this.validators = validators;
+    const stakeNeeded = (await rollup.read.getActivationThreshold()) * BigInt(this.numberOfValidators);
+    await Promise.all(
+      [await stakingAsset.write.mint([multiAdder.address, stakeNeeded], {} as any)].map(txHash =>
+        this.context.deployL1ContractsValues.l1Client.waitForTransactionReceipt({ hash: txHash }),
+      ),
+    );
 
-      const gseAddress = deployL1ContractsValues.l1ContractAddresses.gseAddress!;
-      if (!gseAddress) {
-        throw new Error('GSE contract not deployed');
-      }
+    const { validators } = this.getValidators();
+    this.validators = validators;
 
-      const gseContract = new GSEContract(deployL1ContractsValues.l1Client, gseAddress.toString());
+    const gseAddress = this.context.deployL1ContractsValues.l1ContractAddresses.gseAddress!;
+    if (!gseAddress) {
+      throw new Error('GSE contract not deployed');
+    }
+
+    const gseContract = new GSEContract(this.context.deployL1ContractsValues.l1Client, gseAddress.toString());
 
-      const makeValidatorTuples = async (validator: Operator) => {
-        const registrationTuple = await gseContract.makeRegistrationTuple(validator.bn254SecretKey.getValue());
-        return {
-          attester: validator.attester.toString() as `0x${string}`,
-          withdrawer: validator.withdrawer.toString() as `0x${string}`,
-          ...registrationTuple,
-        };
+    const makeValidatorTuples = async (validator: Operator) => {
+      const registrationTuple = await gseContract.makeRegistrationTuple(validator.bn254SecretKey.getValue());
+      return {
+        attester: validator.attester.toString() as `0x${string}`,
+        withdrawer: validator.withdrawer.toString() as `0x${string}`,
+        ...registrationTuple,
       };
-      const validatorTuples = await Promise.all(validators.map(makeValidatorTuples));
+    };
+    const validatorTuples = await Promise.all(validators.map(makeValidatorTuples));
 
-      await deployL1ContractsValues.l1Client.waitForTransactionReceipt({
-        hash: await multiAdder.write.addValidators([validatorTuples]),
-      });
+    await this.context.deployL1ContractsValues.l1Client.waitForTransactionReceipt({
+      hash: await multiAdder.write.addValidators([validatorTuples]),
+    });
 
-      await cheatCodes.rollup.advanceToEpoch(
-        (await cheatCodes.rollup.getEpoch()) + (await rollup.read.getLagInEpochs()) + 1n,
-      );
+    await this.context.cheatCodes.rollup.advanceToEpoch(
+      EpochNumber.fromBigInt(
+        BigInt(await this.context.cheatCodes.rollup.getEpoch()) +
+          (await rollup.read.getLagInEpochsForValidatorSet()) +
+          1n,
+      ),
+    );
 
-      // Send and await a tx to make sure we mine a block for the warp to correctly progress.
-      await this._sendDummyTx(deployL1ContractsValues.l1Client);
-    });
+    // Send and await a tx to make sure we mine a block for the warp to correctly progress.
+    await this._sendDummyTx(this.context.deployL1ContractsValues.l1Client);
   }
 
+  /** Points the wallet to a P2P-enabled node so transactions can propagate through the network. */
+  setupWalletOnNode(node: AztecNodeService) {
+    this.logger.info('Pointing wallet to a P2P-enabled node');
+    this.context.wallet.updateNode(node);
+  }
+
+  /** Registers the hardcoded account in PXE without on-chain deployment. No sequencer needed. */
   async setupAccount() {
-    await this.snapshotManager.snapshot(
-      'setup-account',
-      deployAccounts(1, this.logger),
-      ({ deployedAccounts }, { wallet }) => {
-        this.deployedAccounts = deployedAccounts;
-        [{ address: this.defaultAccountAddress }] = deployedAccounts;
-        this.wallet = wallet;
-        return Promise.resolve();
-      },
-    );
+    this.logger.info('Registering hardcoded account (no deployment)');
+    const contract = new SchnorrHardcodedKeyAccountContract();
+    const accountManager = await (this.context.wallet as TestWallet).createAccount({
+      secret: this.hardcodedAccountData.secret,
+      salt: this.hardcodedAccountData.salt,
+      contract,
+    });
+    this.defaultAccountAddress = accountManager.address;
+    this.wallet = this.context.wallet;
   }
 
   async deploySpamContract() {
-    await this.snapshotManager.snapshot(
-      'add-spam-contract',
-      async () => {
-        if (!this.wallet) {
-          throw new Error('Call snapshot t.setupAccount before deploying account contract');
-        }
-
-        const spamContract = await SpamContract.deploy(this.wallet)
-          .send({ from: this.defaultAccountAddress! })
-          .deployed();
-        return { contractAddress: spamContract.address };
-      },
-      async ({ contractAddress }) => {
-        if (!this.wallet) {
-          throw new Error('Call snapshot t.setupAccount before deploying account contract');
-        }
-        this.spamContract = await SpamContract.at(contractAddress, this.wallet);
-      },
-    );
+    this.logger.info('Deploying spam contract');
+    if (!this.wallet) {
+      throw new Error('Call setupAccount before deploying spam contract');
+    }
+
+    ({ contract: this.spamContract } = await SpamContract.deploy(this.wallet).send({
+      from: this.defaultAccountAddress!,
+    }));
   }
 
   async removeInitialNode() {
-    await this.snapshotManager.snapshot(
-      'remove-initial-validator',
-      async ({ deployL1ContractsValues, aztecNode, dateProvider }) => {
-        // Send and await a tx to make sure we mine a block for the warp to correctly progress.
-        const { receipt } = await this._sendDummyTx(deployL1ContractsValues.l1Client);
-        const block = await deployL1ContractsValues.l1Client.getBlock({
-          blockNumber: receipt.blockNumber,
-        });
-        dateProvider.setTime(Number(block.timestamp) * 1000);
-
-        await aztecNode.stop();
-      },
-    );
+    this.logger.info('Removing initial node');
+    // Send and await a tx to make sure we mine a block for the warp to correctly progress.
+    const { receipt } = await this._sendDummyTx(this.context.deployL1ContractsValues.l1Client);
+    const block = await this.context.deployL1ContractsValues.l1Client.getBlock({
+      blockNumber: receipt.blockNumber,
+    });
+    this.context.dateProvider.setTime(Number(block.timestamp) * 1000);
+
+    await this.context.aztecNodeService.stop();
   }
 
   async sendDummyTx() {
@@ -356,7 +347,7 @@ export class P2PNetworkTest {
   }
 
   private async _sendDummyTx(l1Client: ExtendedViemWalletClient) {
-    const l1TxUtils = createL1TxUtilsFromViemWallet(l1Client);
+    const l1TxUtils = createL1TxUtils(l1Client);
     return await l1TxUtils.sendAndMonitorTransaction({
       to: l1Client.account!.address,
       value: 1n,
@@ -364,17 +355,53 @@ export class P2PNetworkTest {
   }
 
   async setup() {
-    this.ctx = await this.snapshotManager.setup();
+    this.logger.info('Setting up subsystems from fresh');
+
+    // Pre-compute hardcoded account data so it gets funded in genesis.
+    const contract = new SchnorrHardcodedKeyAccountContract();
+    const secret = Fr.random();
+    const salt = Fr.random();
+    this.hardcodedAccountData = {
+      secret,
+      salt,
+      signingKey: SCHNORR_HARDCODED_PRIVATE_KEY,
+      address: await getAccountContractAddress(contract, secret, salt),
+    };
+
+    // Generate regular Schnorr accounts for tests that need deployable accounts (e.g. add_rollup).
+    const regularAccounts = await generateSchnorrAccounts(this.setupOptions.numberOfInitialFundedAccounts ?? 2);
+
+    this.context = await setup(
+      0,
+      {
+        ...this.setupOptions,
+        fundSponsoredFPC: true,
+        skipAccountDeployment: true,
+        skipInitialSequencer: true,
+        initialFundedAccounts: [...regularAccounts, this.hardcodedAccountData],
+        slasherEnabled: this.setupOptions.slasherEnabled ?? this.deployL1ContractsArgs.slasherEnabled ?? false,
+        aztecTargetCommitteeSize: 0,
+        l1ContractsArgs: this.deployL1ContractsArgs,
+      },
+      // Use checkpointed chain tip for PXE to avoid issues with blocks being dropped due to pruned anchor blocks.
+      { syncChainTip: 'checkpointed' },
+    );
+    this.ctx = this.context;
 
     const sponsoredFPCAddress = await getSponsoredFPCAddress();
-    const initialFundedAccounts = [...this.ctx.initialFundedAccounts.map(a => a.address), sponsoredFPCAddress];
+    const initialFundedAccounts = [...this.context.initialFundedAccounts.map(a => a.address), sponsoredFPCAddress];
 
-    const { prefilledPublicData } = await getGenesisValues(initialFundedAccounts);
-    this.prefilledPublicData = prefilledPublicData;
+    const { genesis } = await getGenesisValues(
+      initialFundedAccounts,
+      undefined,
+      undefined,
+      this.context.genesis!.genesisTimestamp,
+    );
+    this.genesis = genesis;
 
-    const rollupContract = RollupContract.getFromL1ContractsValues(this.ctx.deployL1ContractsValues);
-    this.monitor = new ChainMonitor(rollupContract, this.ctx.dateProvider).start();
-    this.monitor.on('l1-block', ({ timestamp }) => this.ctx.dateProvider.setTime(Number(timestamp) * 1000));
+    const rollupContract = RollupContract.getFromL1ContractsValues(this.context.deployL1ContractsValues);
+    this.monitor = new ChainMonitor(rollupContract, this.context.dateProvider).start();
+    this.monitor.on('l1-block', ({ timestamp }) => this.context.dateProvider.setTime(Number(timestamp) * 1000));
   }
 
   async stopNodes(nodes: AztecNodeService[]) {
@@ -405,6 +432,7 @@ export class P2PNetworkTest {
     expectedNodeCount?: number,
     timeoutSeconds = 30,
     checkIntervalSeconds = 0.1,
+    topics: TopicType[] = [TopicType.tx],
   ) {
     const nodeCount = expectedNodeCount ?? nodes.length;
     const minPeerCount = nodeCount - 1;
@@ -430,22 +458,44 @@ export class P2PNetworkTest {
     );
 
     this.logger.warn('All nodes connected to P2P mesh');
+
+    // Wait for GossipSub mesh to form for all specified topics.
+    // We only require at least 1 mesh peer per node because GossipSub
+    // stops grafting once it reaches Dlo peers and won't fill the mesh to all available peers.
+    for (const topic of topics) {
+      this.logger.warn(`Waiting for GossipSub mesh to form for ${topic} topic...`);
+      await Promise.all(
+        nodes.map(async (node, index) => {
+          const p2p = node.getP2P();
+          await retryUntil(
+            async () => {
+              const meshPeers = await p2p.getGossipMeshPeerCount(topic);
+              this.logger.debug(`Node ${index} has ${meshPeers} gossip mesh peers for ${topic} topic`);
+              return meshPeers >= 1 ? true : undefined;
+            },
+            `Node ${index} to have gossip mesh peers for ${topic} topic`,
+            timeoutSeconds,
+            checkIntervalSeconds,
+          );
+        }),
+      );
+      this.logger.warn(`All nodes have gossip mesh peers for ${topic} topic`);
+    }
   }
 
   async teardown() {
     await this.monitor.stop();
     await tryStop(this.bootstrapNode, this.logger);
-    await this.snapshotManager.teardown();
+    await teardown(this.context);
   }
 
   async getContracts(): Promise<{
     rollup: RollupContract;
     slasherContract: GetContractReturnType<typeof SlasherAbi, ViemClient>;
-    slashingProposer: EmpireSlashingProposerContract | TallySlashingProposerContract | undefined;
-    slashFactory: SlashFactoryContract;
+    slashingProposer: SlashingProposerContract | undefined;
   }> {
     if (!this.ctx.deployL1ContractsValues) {
-      throw new Error('DeployL1ContractsValues not set');
+      throw new Error('DeployAztecL1ContractsValues not set');
     }
 
     const rollup = new RollupContract(
@@ -454,19 +504,14 @@ export class P2PNetworkTest {
     );
 
     const slasherContract = getContract({
-      address: getAddress(await rollup.getSlasherAddress()),
+      address: getAddress((await rollup.getSlasherAddress()).toString()),
       abi: SlasherAbi,
       client: this.ctx.deployL1ContractsValues.l1Client,
     });
 
-    // Get the actual slashing proposer from rollup (which handles both empire and tally)
+    // Get the actual slashing proposer from rollup
     const slashingProposer = await rollup.getSlashingProposer();
 
-    const slashFactory = new SlashFactoryContract(
-      this.ctx.deployL1ContractsValues.l1Client,
-      getAddress(this.ctx.deployL1ContractsValues.l1ContractAddresses.slashFactoryAddress!.toString()),
-    );
-
-    return { rollup, slasherContract, slashingProposer, slashFactory };
+    return { rollup, slasherContract, slashingProposer };
   }
 }