@aztec/end-to-end 0.0.0-test.0 → 0.0.1-commit.023c3e5

package/src/e2e_p2p/p2p_network.ts

@@ -1,36 +1,53 @@
-import { getSchnorrWalletWithSecretKey } from '@aztec/accounts/schnorr';
 import type { InitialAccountData } from '@aztec/accounts/testing';
 import type { AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
-import type { AccountWalletWithSecretKey } from '@aztec/aztec.js';
-import { ChainMonitor } from '@aztec/aztec.js/ethereum';
-import { RollupContract, getExpectedAddress, getL1ContractsConfigEnvVars } from '@aztec/ethereum';
-import { L1TxUtilsWithBlobs } from '@aztec/ethereum/l1-tx-utils-with-blobs';
-import { EthCheatCodesWithState } from '@aztec/ethereum/test';
+import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
+import { Fr } from '@aztec/aztec.js/fields';
+import { getL1ContractsConfigEnvVars } from '@aztec/ethereum/config';
+import {
+  type EmpireSlashingProposerContract,
+  GSEContract,
+  RollupContract,
+  type TallySlashingProposerContract,
+} 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 { createL1TxUtilsFromViemWallet } 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 { ForwarderAbi, ForwarderBytecode, RollupAbi, TestERC20Abi } from '@aztec/l1-artifacts';
-import { SpamContract } from '@aztec/noir-contracts.js/Spam';
+import { retryUntil } from '@aztec/foundation/retry';
+import { RollupAbi, SlasherAbi, TestERC20Abi } from '@aztec/l1-artifacts';
+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 { 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 { getContract } from 'viem';
+import { type GetContractReturnType, getAddress, getContract } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 
+import {
+  type EndToEndContext,
+  type SetupOptions,
+  deployAccounts,
+  getPrivateKeyFromIndex,
+  getSponsoredFPCAddress,
+  setup,
+  teardown,
+} from '../fixtures/setup.js';
 import {
   ATTESTER_PRIVATE_KEYS_START_INDEX,
-  PROPOSER_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 { getPrivateKeyFromIndex } from '../fixtures/utils.js';
 import { getEndToEndTestTelemetryClient } from '../fixtures/with_telemetry_utils.js';
 
 // Use a fixed bootstrap node private key so that we can re-use the same snapshot and the nodes can find each other
@@ -38,90 +55,118 @@ const BOOTSTRAP_NODE_PRIVATE_KEY = '080212208f988fc0899e4a73a5aee4d271a5f2067060
 const l1ContractsConfig = getL1ContractsConfigEnvVars();
 export const WAIT_FOR_TX_TIMEOUT = l1ContractsConfig.aztecSlotDuration * 3;
 
-export const SHORTENED_BLOCK_TIME_CONFIG = {
+export const SHORTENED_BLOCK_TIME_CONFIG_NO_PRUNES = {
   aztecSlotDuration: 12,
   ethereumSlotDuration: 4,
+  aztecProofSubmissionWindow: 640,
 };
 
 export class P2PNetworkTest {
-  private snapshotManager: ISnapshotManager;
-  private baseAccount;
+  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 proposerPrivateKeys: `0x${string}`[] = [];
   public peerIdPrivateKeys: string[] = [];
+  public validators: Operator[] = [];
 
   public deployedAccounts: InitialAccountData[] = [];
   public prefilledPublicData: PublicDataTreeLeaf[] = [];
+
   // The re-execution test needs a wallet and a spam contract
-  public wallet?: AccountWalletWithSecretKey;
+  public wallet?: TestWallet;
+  public defaultAccountAddress?: AztecAddress;
   public spamContract?: SpamContract;
 
   public bootstrapNode?: BootstrapNode;
 
-  private cleanupInterval: NodeJS.Timeout | undefined = undefined;
-
-  private gasUtils: L1TxUtilsWithBlobs | undefined = undefined;
+  // Store setup options for use in setup()
+  private setupOptions: SetupOptions;
+  private deployL1ContractsArgs: any;
 
   constructor(
-    testName: string,
+    public readonly testName: string,
     public bootstrapNodeEnr: string,
     public bootNodePort: number,
-    private numberOfNodes: number,
-    initialValidatorConfig: AztecNodeConfig,
+    public numberOfValidators: number,
+    initialValidatorConfig: SetupOptions,
+    public numberOfNodes = 0,
     // If set enable metrics collection
     private metricsPort?: number,
+    startProverNode?: boolean,
   ) {
     this.logger = createLogger(`e2e:e2e_p2p:${testName}`);
 
     // Set up the base account and node private keys for the initial network deployment
-    this.baseAccount = privateKeyToAccount(`0x${getPrivateKeyFromIndex(0)!.toString('hex')}`);
-    this.proposerPrivateKeys = generatePrivateKeys(PROPOSER_PRIVATE_KEYS_START_INDEX, numberOfNodes);
-    this.attesterPrivateKeys = generatePrivateKeys(ATTESTER_PRIVATE_KEYS_START_INDEX, numberOfNodes);
+    this.baseAccountPrivateKey = `0x${getPrivateKeyFromIndex(1)!.toString('hex')}`;
+    this.baseAccount = privateKeyToAccount(this.baseAccountPrivateKey);
+    this.attesterPrivateKeys = generatePrivateKeys(
+      ATTESTER_PRIVATE_KEYS_START_INDEX + numberOfNodes,
+      numberOfValidators,
+    );
     this.attesterPublicKeys = this.attesterPrivateKeys.map(privateKey => privateKeyToAccount(privateKey).address);
 
-    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,
-        aztecProofSubmissionWindow:
-          initialValidatorConfig.aztecProofSubmissionWindow ?? l1ContractsConfig.aztecProofSubmissionWindow,
-        salt: 420,
-        metricsPort: metricsPort,
-        numberOfInitialFundedAccounts: 1,
-      },
-      {
-        aztecEpochDuration: initialValidatorConfig.aztecEpochDuration ?? l1ContractsConfig.aztecEpochDuration,
-        ethereumSlotDuration: initialValidatorConfig.ethereumSlotDuration ?? l1ContractsConfig.ethereumSlotDuration,
-        aztecSlotDuration: initialValidatorConfig.aztecSlotDuration ?? l1ContractsConfig.aztecSlotDuration,
-        aztecProofSubmissionWindow:
-          initialValidatorConfig.aztecProofSubmissionWindow ?? l1ContractsConfig.aztecProofSubmissionWindow,
-        initialValidators: [],
+    const zkPassportParams = ZkPassportProofParams.random();
+
+    // 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,
+      slasherFlavor: initialValidatorConfig.slasherFlavor ?? 'tally',
+      aztecTargetCommitteeSize: numberOfValidators,
+      metricsPort: metricsPort,
+      numberOfInitialFundedAccounts: 2,
+      startProverNode,
+      walletMinFeePadding: 2.0,
+    };
+
+    this.deployL1ContractsArgs = {
+      ...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: {
+        zkPassportDomain: zkPassportParams.domain,
+        zkPassportScope: zkPassportParams.scope,
       },
-    );
+    };
   }
 
   static async create({
     testName,
     numberOfNodes,
+    numberOfValidators,
     basePort,
     metricsPort,
     initialConfig,
+    startProverNode,
   }: {
     testName: string;
     numberOfNodes: number;
+    numberOfValidators: number;
     basePort?: number;
     metricsPort?: number;
-    initialConfig?: Partial<AztecNodeConfig>;
+    initialConfig?: SetupOptions;
+    startProverNode?: boolean;
   }) {
     const port = basePort || (await getPort());
 
@@ -133,213 +178,204 @@ export class P2PNetworkTest {
       bootstrapNodeEnr,
     );
 
-    return new P2PNetworkTest(testName, bootstrapNodeEnr, port, numberOfNodes, initialValidatorConfig, metricsPort);
+    return new P2PNetworkTest(
+      testName,
+      bootstrapNodeEnr,
+      port,
+      numberOfValidators,
+      initialValidatorConfig,
+      numberOfNodes,
+      metricsPort,
+      startProverNode,
+    );
   }
 
   get fundedAccount() {
     if (!this.deployedAccounts[0]) {
-      throw new Error('Call snapshot t.setupAccount to create a funded account.');
+      throw new Error('Call setupAccount to create a funded account.');
     }
     return this.deployedAccounts[0];
   }
 
-  /**
-   * Start a loop to sync the mock system time with the L1 block time
-   */
-  public startSyncMockSystemTimeInterval() {
-    this.cleanupInterval = setInterval(() => {
-      void this.syncMockSystemTime().catch(err => this.logger.error('Error syncing mock system time', err));
-    }, l1ContractsConfig.aztecSlotDuration * 1000);
+  async addBootstrapNode() {
+    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();
   }
 
-  /**
-   * When using fake timers, we need to keep the system and anvil clocks in sync.
-   */
-  public async syncMockSystemTime() {
-    this.logger.info('Syncing mock system time');
-    const { dateProvider, deployL1ContractsValues } = this.ctx!;
-    // Send a tx and only update the time after the tx is mined, as eth time is not continuous
-    const { receipt } = await this.gasUtils!.sendAndMonitorTransaction({
-      to: this.baseAccount.address,
-      data: '0x',
-      value: 1n,
-    });
-    const timestamp = await deployL1ContractsValues.publicClient.getBlock({ blockNumber: receipt.blockNumber });
-    this.logger.info(`Timestamp: ${timestamp.timestamp}`);
-    dateProvider.setTime(Number(timestamp.timestamp) * 1000);
+  getValidators() {
+    const validators: Operator[] = [];
+
+    for (let i = 0; i < this.numberOfValidators; i++) {
+      const keyIndex = i;
+      const attester = privateKeyToAccount(this.attesterPrivateKeys[keyIndex]!);
+
+      validators.push({
+        attester: EthAddress.fromString(attester.address),
+        withdrawer: EthAddress.fromString(attester.address),
+        bn254SecretKey: new SecretValue(Fr.random().toBigInt()),
+      });
+
+      this.logger.info(`Adding attester ${attester.address} as validator`);
+    }
+    return { validators };
   }
 
-  async applyBaseSnapshots() {
-    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();
+  async applyBaseSetup() {
+    await this.addBootstrapNode();
+
+    this.logger.info('Adding validators');
+    const rollup = getContract({
+      address: this.context.deployL1ContractsValues.l1ContractAddresses.rollupAddress.toString(),
+      abi: RollupAbi,
+      client: this.context.deployL1ContractsValues.l1Client,
     });
 
-    await this.snapshotManager.snapshot(
-      'add-validators',
-      async ({ deployL1ContractsValues, aztecNodeConfig, dateProvider }) => {
-        const rollup = getContract({
-          address: deployL1ContractsValues.l1ContractAddresses.rollupAddress.toString(),
-          abi: RollupAbi,
-          client: deployL1ContractsValues.walletClient,
-        });
-
-        this.logger.verbose(`Adding ${this.numberOfNodes} validators`);
-
-        const stakingAsset = getContract({
-          address: deployL1ContractsValues.l1ContractAddresses.stakingAssetAddress.toString(),
-          abi: TestERC20Abi,
-          client: deployL1ContractsValues.walletClient,
-        });
-
-        const stakeNeeded = l1ContractsConfig.minimumStake * BigInt(this.numberOfNodes);
-        await Promise.all(
-          [
-            await stakingAsset.write.mint(
-              [deployL1ContractsValues.walletClient.account.address, stakeNeeded],
-              {} as any,
-            ),
-            await stakingAsset.write.approve(
-              [deployL1ContractsValues.l1ContractAddresses.rollupAddress.toString(), stakeNeeded],
-              {} as any,
-            ),
-          ].map(txHash => deployL1ContractsValues.publicClient.waitForTransactionReceipt({ hash: txHash })),
-        );
+    this.logger.info(`Adding ${this.numberOfValidators} validators`);
 
-        const validators = [];
-
-        for (let i = 0; i < this.numberOfNodes; i++) {
-          const attester = privateKeyToAccount(this.attesterPrivateKeys[i]!);
-          const proposerEOA = privateKeyToAccount(this.proposerPrivateKeys[i]!);
-          const forwarder = getExpectedAddress(
-            ForwarderAbi,
-            ForwarderBytecode,
-            [proposerEOA.address],
-            proposerEOA.address,
-          ).address;
-          validators.push({
-            attester: attester.address,
-            proposer: forwarder,
-            withdrawer: attester.address,
-            amount: l1ContractsConfig.minimumStake,
-          } as const);
-
-          this.logger.verbose(`Adding (attester, proposer) pair: (${attester.address}, ${forwarder}) as validator`);
-        }
-
-        await deployL1ContractsValues.publicClient.waitForTransactionReceipt({
-          hash: await rollup.write.cheat__InitialiseValidatorSet([validators]),
-        });
-
-        const slotsInEpoch = await rollup.read.getEpochDuration();
-        const timestamp = await rollup.read.getTimestampForSlot([slotsInEpoch]);
-        const cheatCodes = new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls);
-        try {
-          await cheatCodes.warp(Number(timestamp));
-        } catch (err) {
-          this.logger.debug('Warp failed, time already satisfied');
-        }
-
-        // Send and await a tx to make sure we mine a block for the warp to correctly progress.
-        await deployL1ContractsValues.publicClient.waitForTransactionReceipt({
-          hash: await deployL1ContractsValues.walletClient.sendTransaction({
-            to: this.baseAccount.address,
-            value: 1n,
-            account: this.baseAccount,
-          }),
-        });
-
-        // Set the system time in the node, only after we have warped the time and waited for a block
-        // Time is only set in the NEXT block
-        dateProvider.setTime(Number(timestamp) * 1000);
-      },
+    const stakingAsset = getContract({
+      address: this.context.deployL1ContractsValues.l1ContractAddresses.stakingAssetAddress.toString(),
+      abi: TestERC20Abi,
+      client: this.context.deployL1ContractsValues.l1Client,
+    });
+
+    const { address: multiAdderAddress } = await deployL1Contract(
+      this.context.deployL1ContractsValues.l1Client,
+      MultiAdderArtifact.contractAbi,
+      MultiAdderArtifact.contractBytecode,
+      [rollup.address, this.context.deployL1ContractsValues.l1Client.account.address],
+    );
+
+    const multiAdder = getContract({
+      address: multiAdderAddress.toString(),
+      abi: MultiAdderArtifact.contractAbi,
+      client: this.context.deployL1ContractsValues.l1Client,
+    });
+
+    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 { validators } = this.getValidators();
+    this.validators = validators;
+
+    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 validatorTuples = await Promise.all(validators.map(makeValidatorTuples));
+
+    await this.context.deployL1ContractsValues.l1Client.waitForTransactionReceipt({
+      hash: await multiAdder.write.addValidators([validatorTuples]),
+    });
+
+    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(this.context.deployL1ContractsValues.l1Client);
   }
 
   async setupAccount() {
-    await this.snapshotManager.snapshot(
-      'setup-account',
-      deployAccounts(1, this.logger, false),
-      async ({ deployedAccounts }, { pxe }) => {
-        this.deployedAccounts = deployedAccounts;
-        const [account] = deployedAccounts;
-        this.wallet = await getSchnorrWalletWithSecretKey(pxe, account.secret, account.signingKey, account.salt);
-      },
-    );
+    this.logger.info('Setting up account');
+    const { deployedAccounts } = await deployAccounts(
+      1,
+      this.logger,
+    )({
+      wallet: this.context.wallet,
+      initialFundedAccounts: this.context.initialFundedAccounts,
+    });
+    this.deployedAccounts = deployedAccounts;
+    [{ address: this.defaultAccountAddress }] = deployedAccounts;
+    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().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');
+    }
+
+    const spamContract = await SpamContract.deploy(this.wallet).send({ from: this.defaultAccountAddress! });
+    this.spamContract = spamContract;
   }
 
   async removeInitialNode() {
-    await this.snapshotManager.snapshot(
-      'remove-inital-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 deployL1ContractsValues.publicClient.waitForTransactionReceipt({
-          hash: await deployL1ContractsValues.walletClient.sendTransaction({
-            to: this.baseAccount.address,
-            value: 1n,
-            account: this.baseAccount,
-          }),
-        });
-        const block = await deployL1ContractsValues.publicClient.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);
 
-  async setup() {
-    this.ctx = await this.snapshotManager.setup();
+    await this.context.aztecNodeService!.stop();
+  }
 
-    this.prefilledPublicData = (
-      await getGenesisValues(this.ctx.initialFundedAccounts.map(a => a.address))
-    ).prefilledPublicData;
+  async sendDummyTx() {
+    return await this._sendDummyTx(this.ctx.deployL1ContractsValues.l1Client);
+  }
 
-    this.startSyncMockSystemTimeInterval();
+  private async _sendDummyTx(l1Client: ExtendedViemWalletClient) {
+    const l1TxUtils = createL1TxUtilsFromViemWallet(l1Client);
+    return await l1TxUtils.sendAndMonitorTransaction({
+      to: l1Client.account!.address,
+      value: 1n,
+    });
+  }
 
-    this.gasUtils = new L1TxUtilsWithBlobs(
-      this.ctx.deployL1ContractsValues.publicClient,
-      this.ctx.deployL1ContractsValues.walletClient,
-      this.logger,
+  async setup() {
+    this.logger.info('Setting up subsystems from fresh');
+    this.context = await setup(
+      0,
       {
-        gasLimitBufferPercentage: 20,
-        maxGwei: 500n,
-        maxAttempts: 3,
-        checkIntervalMs: 100,
-        stallTimeMs: 1000,
+        ...this.setupOptions,
+        fundSponsoredFPC: true,
+        skipAccountDeployment: true,
+        slasherFlavor: this.setupOptions.slasherFlavor ?? this.deployL1ContractsArgs.slasherFlavor ?? 'none',
+        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.context.initialFundedAccounts.map(a => a.address), sponsoredFPCAddress];
 
-    this.monitor = new ChainMonitor(RollupContract.getFromL1ContractsValues(this.ctx.deployL1ContractsValues)).start();
+    const { prefilledPublicData } = await getGenesisValues(initialFundedAccounts);
+    this.prefilledPublicData = prefilledPublicData;
+
+    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[]) {
@@ -355,12 +391,83 @@ export class P2PNetworkTest {
     this.logger.info('Nodes stopped');
   }
 
+  /**
+   * Wait for P2P mesh to be fully formed across all nodes.
+   * This ensures that all nodes are connected to each other before proceeding,
+   * preventing race conditions where validators propose blocks before the network is ready.
+   *
+   * @param nodes - Array of nodes to check for P2P connectivity
+   * @param expectedNodeCount - Expected number of nodes in the network (defaults to nodes.length)
+   * @param timeoutSeconds - Maximum time to wait for connections (default: 30 seconds)
+   * @param checkIntervalSeconds - How often to check connectivity (default: 0.1 seconds)
+   */
+  async waitForP2PMeshConnectivity(
+    nodes: AztecNodeService[],
+    expectedNodeCount?: number,
+    timeoutSeconds = 30,
+    checkIntervalSeconds = 0.1,
+  ) {
+    const nodeCount = expectedNodeCount ?? nodes.length;
+    const minPeerCount = nodeCount - 1;
+
+    this.logger.warn(
+      `Waiting for all ${nodeCount} nodes to connect to P2P mesh (at least ${minPeerCount} peers each)...`,
+    );
+
+    await Promise.all(
+      nodes.map(async (node, index) => {
+        const p2p = node.getP2P();
+        await retryUntil(
+          async () => {
+            const peers = await p2p.getPeers();
+            // Each node should be connected to at least N-1 other nodes
+            return peers.length >= minPeerCount ? true : undefined;
+          },
+          `Node ${index} to connect to at least ${minPeerCount} peers`,
+          timeoutSeconds,
+          checkIntervalSeconds,
+        );
+      }),
+    );
+
+    this.logger.warn('All nodes connected to P2P mesh');
+  }
+
   async teardown() {
-    this.monitor.stop();
-    await this.bootstrapNode?.stop();
-    await this.snapshotManager.teardown();
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
+    await this.monitor.stop();
+    await tryStop(this.bootstrapNode, this.logger);
+    await teardown(this.context);
+  }
+
+  async getContracts(): Promise<{
+    rollup: RollupContract;
+    slasherContract: GetContractReturnType<typeof SlasherAbi, ViemClient>;
+    slashingProposer: EmpireSlashingProposerContract | TallySlashingProposerContract | undefined;
+    slashFactory: SlashFactoryContract;
+  }> {
+    if (!this.ctx.deployL1ContractsValues) {
+      throw new Error('DeployAztecL1ContractsValues not set');
     }
+
+    const rollup = new RollupContract(
+      this.ctx.deployL1ContractsValues!.l1Client,
+      this.ctx.deployL1ContractsValues!.l1ContractAddresses.rollupAddress,
+    );
+
+    const slasherContract = getContract({
+      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)
+    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 };
   }
 }