@aztec/end-to-end 0.0.1-commit.d3ec352c → 0.0.1-commit.d58ff9d0

package/src/e2e_p2p/inactivity_slash_test.ts

@@ -1,182 +0,0 @@
-import type { AztecNodeService } from '@aztec/aztec-node';
-import { EthAddress } from '@aztec/aztec.js/addresses';
-import { RollupContract } from '@aztec/ethereum';
-import { EpochNumber } from '@aztec/foundation/branded-types';
-
-import fs from 'fs';
-import 'jest-extended';
-import os from 'os';
-import path from 'path';
-
-import { createNodes } from '../fixtures/setup_p2p_test.js';
-import { P2PNetworkTest } from './p2p_network.js';
-
-const NUM_NODES = 6;
-const NUM_VALIDATORS = NUM_NODES;
-const COMMITTEE_SIZE = NUM_VALIDATORS;
-const SLASHING_QUORUM = 3;
-const EPOCH_DURATION = 2;
-const SLASHING_ROUND_SIZE_IN_EPOCHS = 2;
-const BOOT_NODE_UDP_PORT = 4500;
-const ETHEREUM_SLOT_DURATION = process.env.CI ? 8 : 4;
-const AZTEC_SLOT_DURATION = ETHEREUM_SLOT_DURATION * 2;
-const SLASHING_UNIT = BigInt(1e18);
-const SLASHING_AMOUNT = SLASHING_UNIT * 3n;
-
-// How many epochs it may take to set everything up, so we dont slash during this period
-const SETUP_EPOCH_DURATION = 5;
-
-export class P2PInactivityTest {
-  public nodes!: AztecNodeService[];
-  public activeNodes!: AztecNodeService[];
-  public inactiveNodes!: AztecNodeService[];
-
-  public rollup!: RollupContract;
-  public offlineValidators!: EthAddress[];
-
-  private dataDir: string;
-  private inactiveNodeCount: number;
-  private keepInitialNode: boolean;
-
-  constructor(
-    public readonly test: P2PNetworkTest,
-    opts: { inactiveNodeCount: number; keepInitialNode?: boolean },
-  ) {
-    this.dataDir = fs.mkdtempSync(path.join(os.tmpdir(), test.testName));
-    this.inactiveNodeCount = opts.inactiveNodeCount;
-    this.keepInitialNode = opts.keepInitialNode ?? false;
-  }
-
-  static async create(
-    testName: string,
-    opts: { slashInactivityConsecutiveEpochThreshold: number; inactiveNodeCount: number; keepInitialNode?: boolean },
-  ) {
-    const test = await P2PNetworkTest.create({
-      testName,
-      numberOfNodes: 0,
-      numberOfValidators: NUM_VALIDATORS,
-      basePort: BOOT_NODE_UDP_PORT,
-      startProverNode: true,
-      initialConfig: {
-        proverNodeConfig: { proverNodeEpochProvingDelayMs: AZTEC_SLOT_DURATION * 1000 },
-        aztecTargetCommitteeSize: COMMITTEE_SIZE,
-        aztecSlotDuration: AZTEC_SLOT_DURATION,
-        ethereumSlotDuration: ETHEREUM_SLOT_DURATION,
-        aztecProofSubmissionEpochs: 1024, // effectively do not reorg
-        listenAddress: '127.0.0.1',
-        minTxsPerBlock: 0,
-        aztecEpochDuration: EPOCH_DURATION,
-        validatorReexecute: false,
-        sentinelEnabled: true,
-        slashingQuorum: SLASHING_QUORUM,
-        slashingRoundSizeInEpochs: SLASHING_ROUND_SIZE_IN_EPOCHS,
-        slashInactivityTargetPercentage: 0.8,
-        slashGracePeriodL2Slots: SETUP_EPOCH_DURATION * EPOCH_DURATION, // do not slash during setup
-        slashAmountSmall: SLASHING_UNIT,
-        slashAmountMedium: SLASHING_UNIT * 2n,
-        slashAmountLarge: SLASHING_UNIT * 3n,
-        ...opts,
-      },
-    });
-    return new P2PInactivityTest(test, opts);
-  }
-
-  public async setup() {
-    await this.test.applyBaseSnapshots();
-    await this.test.setup();
-
-    // Set slashing penalties for inactivity
-    const { rollup } = await this.test.getContracts();
-    const [activationThreshold, ejectionThreshold, localEjectionThreshold] = await Promise.all([
-      rollup.getActivationThreshold(),
-      rollup.getEjectionThreshold(),
-      rollup.getLocalEjectionThreshold(),
-    ]);
-    const biggestEjection = ejectionThreshold > localEjectionThreshold ? ejectionThreshold : localEjectionThreshold;
-    expect(activationThreshold - SLASHING_AMOUNT).toBeLessThan(biggestEjection);
-    this.test.ctx.aztecNodeConfig.slashInactivityPenalty = SLASHING_AMOUNT;
-    this.rollup = rollup;
-
-    if (!this.keepInitialNode) {
-      await this.test.ctx.aztecNode.stop();
-    }
-
-    // Create all active nodes
-    this.activeNodes = await createNodes(
-      this.test.ctx.aztecNodeConfig,
-      this.test.ctx.dateProvider,
-      this.test.bootstrapNodeEnr,
-      NUM_NODES - this.inactiveNodeCount - Number(this.keepInitialNode),
-      BOOT_NODE_UDP_PORT,
-      this.test.prefilledPublicData,
-      this.dataDir,
-      undefined,
-      Number(this.keepInitialNode),
-    );
-
-    // And the ones with an initially disabled sequencer
-    const inactiveConfig = { ...this.test.ctx.aztecNodeConfig, dontStartSequencer: true };
-    this.inactiveNodes = await createNodes(
-      inactiveConfig,
-      this.test.ctx.dateProvider,
-      this.test.bootstrapNodeEnr,
-      this.inactiveNodeCount,
-      BOOT_NODE_UDP_PORT,
-      this.test.prefilledPublicData,
-      this.dataDir,
-      undefined,
-      NUM_NODES - this.inactiveNodeCount,
-    );
-
-    this.nodes = [
-      ...(this.keepInitialNode ? [this.test.ctx.aztecNode] : []),
-      ...this.activeNodes,
-      ...this.inactiveNodes,
-    ];
-
-    if (this.nodes.length !== NUM_NODES) {
-      throw new Error(`Expected ${NUM_NODES} nodes but got ${this.nodes.length}`);
-    }
-
-    this.offlineValidators = this.test.validators
-      .slice(this.test.validators.length - this.inactiveNodeCount)
-      .map(a => a.attester);
-
-    this.test.logger.warn(`Setup complete. Offline validators are ${this.offlineValidators.join(', ')}.`, {
-      validators: this.test.validators,
-      offlineValidators: this.offlineValidators,
-    });
-
-    // Wait for P2P mesh to be fully formed before starting slashing period
-    // This prevents race conditions where validators propose blocks before the network is ready
-    await this.test.waitForP2PMeshConnectivity(this.nodes, NUM_NODES);
-
-    const ethereumSlotDuration = this.test.ctx.aztecNodeConfig.ethereumSlotDuration!;
-    this.test.logger.warn(`Advancing to the L1 slot before epoch ${SETUP_EPOCH_DURATION + 1} to start slashing`);
-    await this.test.ctx.cheatCodes.rollup.advanceToEpoch(EpochNumber(SETUP_EPOCH_DURATION + 1), {
-      offset: -ethereumSlotDuration,
-    });
-
-    return this;
-  }
-
-  public async teardown() {
-    await this.test.stopNodes(this.nodes);
-    await this.test.teardown();
-    for (let i = 0; i < NUM_NODES; i++) {
-      fs.rmSync(`${this.dataDir}-${i}`, { recursive: true, force: true, maxRetries: 3 });
-    }
-  }
-
-  public get ctx() {
-    return this.test.ctx;
-  }
-
-  public get logger() {
-    return this.test.logger;
-  }
-
-  public get slashingAmount() {
-    return SLASHING_AMOUNT;
-  }
-}

package/src/e2e_p2p/p2p_network.ts

@@ -1,476 +0,0 @@
-import type { InitialAccountData } from '@aztec/accounts/testing';
-import type { AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
-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 { ChainMonitor } from '@aztec/ethereum/test';
-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';
-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 { type GetContractReturnType, getAddress, getContract } from 'viem';
-import { privateKeyToAccount } from 'viem/accounts';
-
-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';
-
-// 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';
-const l1ContractsConfig = getL1ContractsConfigEnvVars();
-export const WAIT_FOR_TX_TIMEOUT = l1ContractsConfig.aztecSlotDuration * 3;
-
-export const SHORTENED_BLOCK_TIME_CONFIG_NO_PRUNES = {
-  aztecSlotDuration: 12,
-  ethereumSlotDuration: 4,
-  aztecProofSubmissionWindow: 640,
-};
-
-export class P2PNetworkTest {
-  private snapshotManager: ISnapshotManager;
-  public baseAccountPrivateKey: `0x${string}`;
-  public baseAccount;
-
-  public logger: Logger;
-  public monitor!: ChainMonitor;
-
-  public ctx!: SubsystemsContext;
-  public attesterPrivateKeys: `0x${string}`[] = [];
-  public attesterPublicKeys: 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?: TestWallet;
-  public defaultAccountAddress?: AztecAddress;
-  public spamContract?: SpamContract;
-
-  public bootstrapNode?: BootstrapNode;
-
-  constructor(
-    public readonly testName: string,
-    public bootstrapNodeEnr: string,
-    public bootNodePort: number,
-    public numberOfValidators: number,
-    initialValidatorConfig: SetupOptions,
-    public numberOfNodes = 0,
-    // If set enable metrics collection
-    private metricsPort?: number,
-    startProverNode?: boolean,
-    mockZkPassportVerifier?: boolean,
-  ) {
-    this.logger = createLogger(`e2e:e2e_p2p:${testName}`);
-
-    // Set up the base account and node private keys for the initial network deployment
-    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);
-
-    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,
-        },
-      },
-    );
-  }
-
-  static async create({
-    testName,
-    numberOfNodes,
-    numberOfValidators,
-    basePort,
-    metricsPort,
-    initialConfig,
-    startProverNode,
-    mockZkPassportVerifier,
-  }: {
-    testName: string;
-    numberOfNodes: number;
-    numberOfValidators: number;
-    basePort?: number;
-    metricsPort?: number;
-    initialConfig?: SetupOptions;
-    startProverNode?: boolean;
-    mockZkPassportVerifier?: boolean;
-  }) {
-    const port = basePort || (await getPort());
-
-    const bootstrapNodeENR = await getBootstrapNodeEnr(BOOTSTRAP_NODE_PRIVATE_KEY, port);
-    const bootstrapNodeEnr = bootstrapNodeENR.encodeTxt();
-
-    const initialValidatorConfig = await createValidatorConfig(
-      (initialConfig ?? {}) as AztecNodeConfig,
-      bootstrapNodeEnr,
-    );
-
-    return new P2PNetworkTest(
-      testName,
-      bootstrapNodeEnr,
-      port,
-      numberOfValidators,
-      initialValidatorConfig,
-      numberOfNodes,
-      metricsPort,
-      startProverNode,
-      mockZkPassportVerifier,
-    );
-  }
-
-  get fundedAccount() {
-    if (!this.deployedAccounts[0]) {
-      throw new Error('Call snapshot t.setupAccount to create a funded account.');
-    }
-    return this.deployedAccounts[0];
-  }
-
-  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();
-    });
-  }
-
-  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.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`);
-
-      const stakingAsset = getContract({
-        address: deployL1ContractsValues.l1ContractAddresses.stakingAssetAddress.toString(),
-        abi: TestERC20Abi,
-        client: deployL1ContractsValues.l1Client,
-      });
-
-      const { address: multiAdderAddress } = await deployL1Contract(
-        deployL1ContractsValues.l1Client,
-        MultiAdderArtifact.contractAbi,
-        MultiAdderArtifact.contractBytecode,
-        [rollup.address, deployL1ContractsValues.l1Client.account.address],
-      );
-
-      const multiAdder = getContract({
-        address: multiAdderAddress.toString(),
-        abi: MultiAdderArtifact.contractAbi,
-        client: 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 =>
-          deployL1ContractsValues.l1Client.waitForTransactionReceipt({ hash: txHash }),
-        ),
-      );
-
-      const { validators } = this.getValidators();
-      this.validators = validators;
-
-      const gseAddress = deployL1ContractsValues.l1ContractAddresses.gseAddress!;
-      if (!gseAddress) {
-        throw new Error('GSE contract not deployed');
-      }
-
-      const gseContract = new GSEContract(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 deployL1ContractsValues.l1Client.waitForTransactionReceipt({
-        hash: await multiAdder.write.addValidators([validatorTuples]),
-      });
-
-      await cheatCodes.rollup.advanceToEpoch(
-        EpochNumber.fromBigInt(
-          BigInt(await 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);
-    });
-  }
-
-  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();
-      },
-    );
-  }
-
-  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 };
-      },
-      ({ contractAddress }) => {
-        if (!this.wallet) {
-          throw new Error('Call snapshot t.setupAccount before deploying account contract');
-        }
-        this.spamContract = SpamContract.at(contractAddress, this.wallet);
-        return Promise.resolve();
-      },
-    );
-  }
-
-  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();
-      },
-    );
-  }
-
-  async sendDummyTx() {
-    return await this._sendDummyTx(this.ctx.deployL1ContractsValues.l1Client);
-  }
-
-  private async _sendDummyTx(l1Client: ExtendedViemWalletClient) {
-    const l1TxUtils = createL1TxUtilsFromViemWallet(l1Client);
-    return await l1TxUtils.sendAndMonitorTransaction({
-      to: l1Client.account!.address,
-      value: 1n,
-    });
-  }
-
-  async setup() {
-    this.ctx = await this.snapshotManager.setup();
-
-    const sponsoredFPCAddress = await getSponsoredFPCAddress();
-    const initialFundedAccounts = [...this.ctx.initialFundedAccounts.map(a => a.address), sponsoredFPCAddress];
-
-    const { prefilledPublicData } = await getGenesisValues(initialFundedAccounts);
-    this.prefilledPublicData = prefilledPublicData;
-
-    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));
-  }
-
-  async stopNodes(nodes: AztecNodeService[]) {
-    this.logger.info('Stopping nodes');
-
-    if (!nodes || !nodes.length) {
-      this.logger.info('No nodes to stop');
-      return;
-    }
-
-    await Promise.all(nodes.map(node => node.stop()));
-
-    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() {
-    await this.monitor.stop();
-    await tryStop(this.bootstrapNode, this.logger);
-    await this.snapshotManager.teardown();
-  }
-
-  async getContracts(): Promise<{
-    rollup: RollupContract;
-    slasherContract: GetContractReturnType<typeof SlasherAbi, ViemClient>;
-    slashingProposer: EmpireSlashingProposerContract | TallySlashingProposerContract | undefined;
-    slashFactory: SlashFactoryContract;
-  }> {
-    if (!this.ctx.deployL1ContractsValues) {
-      throw new Error('DeployL1ContractsValues not set');
-    }
-
-    const rollup = new RollupContract(
-      this.ctx.deployL1ContractsValues!.l1Client,
-      this.ctx.deployL1ContractsValues!.l1ContractAddresses.rollupAddress,
-    );
-
-    const slasherContract = getContract({
-      address: getAddress(await rollup.getSlasherAddress()),
-      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 };
-  }
-}