@aztec/end-to-end 0.0.1-commit.d431d1c → 0.0.1-commit.d939eb5aa

package/src/e2e_p2p/inactivity_slash_test.ts

@@ -58,6 +58,7 @@ export class P2PInactivityTest {
       basePort: BOOT_NODE_UDP_PORT,
       startProverNode: true,
       initialConfig: {
+        anvilSlotsInAnEpoch: 4,
         proverNodeConfig: { proverNodeEpochProvingDelayMs: AZTEC_SLOT_DURATION * 1000 },
         aztecTargetCommitteeSize: COMMITTEE_SIZE,
         aztecSlotDuration: AZTEC_SLOT_DURATION,
@@ -66,7 +67,6 @@ export class P2PInactivityTest {
         listenAddress: '127.0.0.1',
         minTxsPerBlock: 0,
         aztecEpochDuration: EPOCH_DURATION,
-        validatorReexecute: false,
         sentinelEnabled: true,
         slashingQuorum: SLASHING_QUORUM,
         slashingRoundSizeInEpochs: SLASHING_ROUND_SIZE_IN_EPOCHS,
@@ -98,17 +98,17 @@ export class P2PInactivityTest {
     this.rollup = rollup;
 
     if (!this.keepInitialNode) {
-      await this.test.ctx.aztecNodeService!.stop();
+      await this.test.ctx.aztecNodeService.stop();
     }
 
     // Create all active nodes
     this.activeNodes = await createNodes(
       this.test.ctx.aztecNodeConfig,
-      this.test.ctx.dateProvider!,
+      this.test.ctx.dateProvider,
       this.test.bootstrapNodeEnr,
       NUM_NODES - this.inactiveNodeCount - Number(this.keepInitialNode),
       BOOT_NODE_UDP_PORT,
-      this.test.prefilledPublicData,
+      this.test.genesis,
       this.dataDir,
       undefined,
       Number(this.keepInitialNode),
@@ -118,18 +118,18 @@ export class P2PInactivityTest {
     const inactiveConfig = { ...this.test.ctx.aztecNodeConfig, dontStartSequencer: true };
     this.inactiveNodes = await createNodes(
       inactiveConfig,
-      this.test.ctx.dateProvider!,
+      this.test.ctx.dateProvider,
       this.test.bootstrapNodeEnr,
       this.inactiveNodeCount,
       BOOT_NODE_UDP_PORT,
-      this.test.prefilledPublicData,
+      this.test.genesis,
       this.dataDir,
       undefined,
       NUM_NODES - this.inactiveNodeCount,
     );
 
     this.nodes = [
-      ...(this.keepInitialNode ? [this.test.ctx.aztecNodeService!] : []),
+      ...(this.keepInitialNode ? [this.test.ctx.aztecNodeService] : []),
       ...this.activeNodes,
       ...this.inactiveNodes,
     ];

package/src/e2e_p2p/p2p_network.ts

@@ -3,16 +3,11 @@ import type { AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
 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 { 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 { createL1TxUtilsFromViemWallet } from '@aztec/ethereum/l1-tx-utils';
+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';
@@ -24,10 +19,10 @@ 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 { TxStatus } from '@aztec/stdlib/tx';
+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';
@@ -49,6 +44,7 @@ import {
   generatePrivateKeys,
 } from '../fixtures/setup_p2p_test.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';
@@ -58,7 +54,7 @@ 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 {
@@ -76,7 +72,7 @@ export class P2PNetworkTest {
   public validators: Operator[] = [];
 
   public deployedAccounts: InitialAccountData[] = [];
-  public prefilledPublicData: PublicDataTreeLeaf[] = [];
+  public genesis: GenesisData | undefined;
 
   // The re-execution test needs a wallet and a spam contract
   public wallet?: TestWallet;
@@ -123,11 +119,12 @@ export class P2PNetworkTest {
         initialValidatorConfig.aztecProofSubmissionEpochs ?? l1ContractsConfig.aztecProofSubmissionEpochs,
       slashingRoundSizeInEpochs:
         initialValidatorConfig.slashingRoundSizeInEpochs ?? l1ContractsConfig.slashingRoundSizeInEpochs,
-      slasherFlavor: initialValidatorConfig.slasherFlavor ?? 'tally',
+      slasherEnabled: initialValidatorConfig.slasherEnabled ?? true,
       aztecTargetCommitteeSize: numberOfValidators,
       metricsPort: metricsPort,
       numberOfInitialFundedAccounts: 2,
       startProverNode,
+      walletMinFeePadding: 2.0,
     };
 
     this.deployL1ContractsArgs = {
@@ -135,7 +132,7 @@ export class P2PNetworkTest {
       aztecEpochDuration: initialValidatorConfig.aztecEpochDuration ?? l1ContractsConfig.aztecEpochDuration,
       slashingRoundSizeInEpochs:
         initialValidatorConfig.slashingRoundSizeInEpochs ?? l1ContractsConfig.slashingRoundSizeInEpochs,
-      slasherFlavor: initialValidatorConfig.slasherFlavor ?? 'tally',
+      slasherEnabled: initialValidatorConfig.slasherEnabled ?? true,
 
       ethereumSlotDuration: initialValidatorConfig.ethereumSlotDuration ?? l1ContractsConfig.ethereumSlotDuration,
       aztecSlotDuration: initialValidatorConfig.aztecSlotDuration ?? l1ContractsConfig.aztecSlotDuration,
@@ -303,10 +300,11 @@ export class P2PNetworkTest {
 
   async setupAccount() {
     this.logger.info('Setting up account');
-    const { deployedAccounts } = await deployAccounts(
-      1,
-      this.logger,
-    )({
+    const { deployedAccounts } = await deployAccounts(1, this.logger, {
+      wait: {
+        waitForStatus: TxStatus.CHECKPOINTED,
+      },
+    })({
       wallet: this.context.wallet,
       initialFundedAccounts: this.context.initialFundedAccounts,
     });
@@ -321,8 +319,9 @@ export class P2PNetworkTest {
       throw new Error('Call setupAccount before deploying spam contract');
     }
 
-    const spamContract = await SpamContract.deploy(this.wallet).send({ from: this.defaultAccountAddress! }).deployed();
-    this.spamContract = spamContract;
+    ({ contract: this.spamContract } = await SpamContract.deploy(this.wallet).send({
+      from: this.defaultAccountAddress!,
+    }));
   }
 
   async removeInitialNode() {
@@ -332,9 +331,9 @@ export class P2PNetworkTest {
     const block = await this.context.deployL1ContractsValues.l1Client.getBlock({
       blockNumber: receipt.blockNumber,
     });
-    this.context.dateProvider!.setTime(Number(block.timestamp) * 1000);
+    this.context.dateProvider.setTime(Number(block.timestamp) * 1000);
 
-    await this.context.aztecNodeService!.stop();
+    await this.context.aztecNodeService.stop();
   }
 
   async sendDummyTx() {
@@ -342,7 +341,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,
@@ -351,25 +350,35 @@ export class P2PNetworkTest {
 
   async setup() {
     this.logger.info('Setting up subsystems from fresh');
-    this.context = await setup(0, {
-      ...this.setupOptions,
-      fundSponsoredFPC: true,
-      skipAccountDeployment: true,
-      slasherFlavor: this.setupOptions.slasherFlavor ?? this.deployL1ContractsArgs.slasherFlavor ?? 'none',
-      aztecTargetCommitteeSize: 0,
-      l1ContractsArgs: this.deployL1ContractsArgs,
-    });
+    this.context = await setup(
+      0,
+      {
+        ...this.setupOptions,
+        fundSponsoredFPC: true,
+        skipAccountDeployment: true,
+        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.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.context.deployL1ContractsValues);
-    this.monitor = new ChainMonitor(rollupContract, this.context.dateProvider!).start();
-    this.monitor.on('l1-block', ({ timestamp }) => this.context.dateProvider!.setTime(Number(timestamp) * 1000));
+    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[]) {
@@ -400,6 +409,7 @@ export class P2PNetworkTest {
     expectedNodeCount?: number,
     timeoutSeconds = 30,
     checkIntervalSeconds = 0.1,
+    topics: TopicType[] = [TopicType.tx],
   ) {
     const nodeCount = expectedNodeCount ?? nodes.length;
     const minPeerCount = nodeCount - 1;
@@ -425,6 +435,29 @@ 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() {
@@ -436,8 +469,7 @@ export class P2PNetworkTest {
   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('DeployAztecL1ContractsValues not set');
@@ -454,14 +486,9 @@ export class P2PNetworkTest {
       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 };
   }
 }

package/src/e2e_p2p/reqresp/utils.ts

@@ -0,0 +1,256 @@
+import type { AztecNodeService } from '@aztec/aztec-node';
+import { createLogger } from '@aztec/aztec.js/log';
+import { waitForTx } from '@aztec/aztec.js/node';
+import { Tx } from '@aztec/aztec.js/tx';
+import { RollupContract } from '@aztec/ethereum/contracts';
+import { CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { timesAsync } from '@aztec/foundation/collection';
+import { retryUntil } from '@aztec/foundation/retry';
+
+import { expect, jest } from '@jest/globals';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+import { getBootNodeUdpPort, shouldCollectMetrics } from '../../fixtures/fixtures.js';
+import { createNodes } from '../../fixtures/setup_p2p_test.js';
+import { P2PNetworkTest, WAIT_FOR_TX_TIMEOUT } from '../p2p_network.js';
+import { prepareTransactions } from '../shared.js';
+
+// Don't set this to a higher value than 9 because each node will use a different L1 publisher account and anvil seeds
+export const NUM_VALIDATORS = 6;
+export const NUM_TXS_PER_NODE = 4;
+export const BOOT_NODE_UDP_PORT = getBootNodeUdpPort();
+
+export const createReqrespDataDir = () => fs.mkdtempSync(path.join(os.tmpdir(), 'reqresp-'));
+
+type ReqrespOptions = {
+  disableStatusHandshake?: boolean;
+};
+
+export async function createReqrespTest(options: ReqrespOptions = {}): Promise<P2PNetworkTest> {
+  const { disableStatusHandshake = false } = options;
+  const t = await P2PNetworkTest.create({
+    testName: 'e2e_p2p_reqresp_tx',
+    numberOfNodes: 0,
+    numberOfValidators: NUM_VALIDATORS,
+    basePort: BOOT_NODE_UDP_PORT,
+    // To collect metrics - run in aztec-packages `docker compose --profile metrics up`
+    metricsPort: shouldCollectMetrics(),
+    initialConfig: {
+      ethereumSlotDuration: 8,
+      aztecSlotDuration: 36,
+      blockDurationMs: 6000,
+      l1PublishingTime: 8,
+      minTxsPerBlock: 1,
+      maxTxsPerBlock: 2,
+      enforceTimeTable: true,
+      aztecProofSubmissionEpochs: 1024, // effectively do not reorg
+      ...(disableStatusHandshake ? { p2pDisableStatusHandshake: true } : {}),
+      listenAddress: '127.0.0.1',
+      aztecEpochDuration: 64, // stable committee
+    },
+  });
+  await t.setup();
+  await t.applyBaseSetup();
+  return t;
+}
+
+export async function cleanupReqrespTest(params: { t: P2PNetworkTest; nodes?: AztecNodeService[]; dataDir: string }) {
+  const { t, nodes, dataDir } = params;
+  if (nodes) {
+    await t.stopNodes(nodes);
+  }
+  await t.teardown();
+  for (let i = 0; i < NUM_VALIDATORS; i++) {
+    fs.rmSync(`${dataDir}-${i}`, { recursive: true, force: true, maxRetries: 3 });
+  }
+}
+
+const getNodePort = (nodeIndex: number) => BOOT_NODE_UDP_PORT + 1 + nodeIndex;
+
+export async function runReqrespTxTest(params: {
+  t: P2PNetworkTest;
+  dataDir: string;
+  disableStatusHandshake?: boolean;
+}): Promise<AztecNodeService[]> {
+  const { t, dataDir, disableStatusHandshake = false } = params;
+
+  if (!t.bootstrapNodeEnr) {
+    throw new Error('Bootstrap node ENR is not available');
+  }
+
+  t.logger.info('Creating nodes');
+  const aztecNodeConfig = disableStatusHandshake
+    ? { ...t.ctx.aztecNodeConfig, p2pDisableStatusHandshake: true }
+    : t.ctx.aztecNodeConfig;
+
+  const nodes = await createNodes(
+    aztecNodeConfig,
+    t.ctx.dateProvider,
+    t.bootstrapNodeEnr,
+    NUM_VALIDATORS,
+    BOOT_NODE_UDP_PORT,
+    t.genesis,
+    dataDir,
+    shouldCollectMetrics(),
+  );
+
+  t.logger.info('Waiting for nodes to connect');
+  await t.waitForP2PMeshConnectivity(nodes, NUM_VALIDATORS);
+
+  await t.setupAccount();
+
+  const targetBlockNumber = await t.ctx.aztecNodeService.getBlockNumber();
+  await retryUntil(
+    async () => {
+      const blockNumbers = await Promise.all(nodes.map(node => node.getBlockNumber()));
+      return blockNumbers.every(blockNumber => blockNumber >= targetBlockNumber) ? true : undefined;
+    },
+    `validators to sync to L2 block ${targetBlockNumber}`,
+    60,
+    0.5,
+  );
+
+  t.logger.info('Preparing transactions to send');
+  const txBatches = await timesAsync(2, () =>
+    prepareTransactions(t.logger, t.ctx.aztecNodeService, NUM_TXS_PER_NODE, t.fundedAccount),
+  );
+
+  t.logger.info('Removing initial node');
+  await t.removeInitialNode();
+
+  t.logger.info('Starting fresh slot');
+  const [timestamp] = await t.ctx.cheatCodes.rollup.advanceToNextSlot();
+  t.ctx.dateProvider.setTime(Number(timestamp) * 1000);
+  const startSlotTimestamp = BigInt(timestamp);
+
+  const { proposerIndexes, nodesToTurnOffTxGossip } = await getProposerIndexes(t, startSlotTimestamp);
+  t.logger.info(`Turning off tx gossip for nodes: ${nodesToTurnOffTxGossip.map(getNodePort)}`);
+  t.logger.info(`Sending txs to proposer nodes: ${proposerIndexes.map(getNodePort)}`);
+
+  // Replace the p2p node implementation of some of the nodes with a spy such that it does not store transactions that are gossiped to it
+  // Original implementation of `handleGossipedTx` will store received transactions in the tx pool.
+  // We chose the first 2 nodes that will be the proposers for the next few slots
+  for (const nodeIndex of nodesToTurnOffTxGossip) {
+    const logger = createLogger(`p2p:${getNodePort(nodeIndex)}`);
+    jest.spyOn((nodes[nodeIndex] as any).p2pClient.p2pService, 'handleGossipedTx').mockImplementation(((
+      payloadData: Buffer,
+    ) => {
+      const txHash = Tx.fromBuffer(payloadData).getTxHash();
+      logger.info(`Skipping storage of gossiped transaction ${txHash.toString()}`);
+      return Promise.resolve();
+    }) as any);
+  }
+
+  // We send the tx to the proposer nodes directly, ignoring the pxe and node in each context
+  // We cannot just call tx.send since they were created using a pxe wired to the first node which is now stopped
+  t.logger.info('Sending transactions through proposer nodes');
+  const submittedTxs = await Promise.all(
+    txBatches.map(async (batch, batchIndex) => {
+      const proposerNode = nodes[proposerIndexes[batchIndex]];
+      for (const tx of batch) {
+        t.logger.info(`Tx ${tx.getTxHash().toString()} base64: ${tx.toBuffer().toString('base64')}`);
+      }
+      const txHashes = batch.map(tx => tx.getTxHash().toString());
+      t.logger.info(
+        `Sending batch ${batchIndex} to proposer ${getNodePort(proposerIndexes[batchIndex])}: ${txHashes.join(', ')}`,
+      );
+      await Promise.all(
+        batch.map(async tx => {
+          try {
+            await proposerNode.sendTx(tx);
+          } catch (err) {
+            t.logger.error(`Error sending tx: ${err}`);
+            throw err;
+          }
+        }),
+      );
+      return batch.map(tx => ({ node: proposerNode, txHash: tx.getTxHash() }));
+    }),
+  );
+
+  // Log pool state per node after sending
+  for (let i = 0; i < NUM_VALIDATORS; i++) {
+    const count = await nodes[i].getPendingTxCount();
+    t.logger.info(`Node ${getNodePort(i)} pool has ${count} pending txs`);
+  }
+
+  t.logger.info('Waiting for all transactions to be mined');
+  await Promise.all(
+    submittedTxs.flatMap((batch, batchIndex) =>
+      batch.map(async (submittedTx, txIndex) => {
+        t.logger.info(`Waiting for tx ${batchIndex}-${txIndex} ${submittedTx.txHash.toString()} to be mined`);
+        await waitForTx(submittedTx.node, submittedTx.txHash, { timeout: WAIT_FOR_TX_TIMEOUT * 1.5 });
+        t.logger.info(`Tx ${batchIndex}-${txIndex} ${submittedTx.txHash.toString()} has been mined`);
+      }),
+    ),
+  );
+
+  t.logger.info('All transactions mined');
+
+  // Assert that multiple blocks were built for at least one slot
+  t.logger.info('Verifying multiple blocks for at least one checkpoint');
+  // Wait for L1 checkpoint sync, which may lag behind P2P block propagation.
+  const checkpoints = await retryUntil(
+    async () => {
+      const cps = await nodes[0].getCheckpoints(CheckpointNumber(1), 50);
+      return cps.length > 0 && cps.some(cp => cp.checkpoint.blocks.length >= 2) ? cps : undefined;
+    },
+    'waiting for multi-block checkpoint to sync from L1',
+    30,
+    1,
+  );
+
+  let mbpsFound = false;
+  let expectedBlockNumber = checkpoints[0].checkpoint.blocks[0].number;
+
+  for (const published of checkpoints) {
+    const blockCount = published.checkpoint.blocks.length;
+    mbpsFound = mbpsFound || blockCount >= 2;
+
+    for (let i = 0; i < blockCount; i++) {
+      const block = published.checkpoint.blocks[i];
+      expect(block.indexWithinCheckpoint).toBe(i);
+      expect(block.checkpointNumber).toBe(published.checkpoint.number);
+      expect(block.number).toBe(expectedBlockNumber);
+      expectedBlockNumber++;
+    }
+  }
+
+  expect(mbpsFound).toBe(true);
+  return nodes;
+}
+
+async function getProposerIndexes(t: P2PNetworkTest, startSlotTimestamp: bigint) {
+  // Get the nodes for the next set of slots
+  const rollupContract = new RollupContract(
+    t.ctx.deployL1ContractsValues.l1Client,
+    t.ctx.deployL1ContractsValues.l1ContractAddresses.rollupAddress,
+  );
+
+  const attesters = await rollupContract.getAttesters();
+  const startSlot = await rollupContract.getSlotAt(startSlotTimestamp);
+
+  const proposers = await Promise.all(
+    Array.from({ length: 3 }, async (_, i) => {
+      const slot = SlotNumber(startSlot + i);
+      const slotTimestamp = await rollupContract.getTimestampForSlot(slot);
+      return await rollupContract.getProposerAt(slotTimestamp);
+    }),
+  );
+  // Get the indexes of the nodes that are responsible for the next two slots
+  const proposerIndexes = proposers.map(proposer => attesters.findIndex(a => a.equals(proposer)));
+
+  if (proposerIndexes.some(i => i === -1)) {
+    throw new Error(
+      `Proposer index not found for proposer ` +
+        `(proposers=${proposers.map(p => p.toString()).join(',')}, indices=${proposerIndexes.join(',')})`,
+    );
+  }
+
+  const nodesToTurnOffTxGossip = Array.from({ length: NUM_VALIDATORS }, (_, i) => i).filter(
+    i => !proposerIndexes.includes(i),
+  );
+  return { proposerIndexes, nodesToTurnOffTxGossip };
+}