@aztec/end-to-end 5.0.0-rc.1 → 5.0.0

package/src/multi-node/slashing/setup.ts

@@ -0,0 +1,433 @@
+import type { AztecNodeService } from '@aztec/aztec-node';
+import type { Logger } from '@aztec/aztec.js/log';
+import type { RollupCheatCodes } from '@aztec/aztec/testing';
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import type { RollupContract, SlashingProposerContract } from '@aztec/ethereum/contracts';
+import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { unique } from '@aztec/foundation/collection';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { retryUntil } from '@aztec/foundation/retry';
+import { pluralize } from '@aztec/foundation/string';
+import { type OffenseType, getRoundForOffense } from '@aztec/slasher';
+import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
+import type { TxHash } from '@aztec/stdlib/tx';
+
+import { jest } from '@jest/globals';
+
+import { testSpan } from '../../fixtures/timing.js';
+import { submitTxsTo } from '../../shared/submit-transactions.js';
+import type { TestWallet } from '../../test-wallet/test_wallet.js';
+import type { MultiNodeTestContext } from '../multi_node_test_context.js';
+
+const TEST_TIMEOUT = 600_000; // 10 minutes
+
+jest.setTimeout(TEST_TIMEOUT);
+
+export const NUM_VALIDATORS = 4;
+export const COMMITTEE_SIZE = NUM_VALIDATORS;
+export const ETHEREUM_SLOT_DURATION = 8;
+export const AZTEC_SLOT_DURATION = ETHEREUM_SLOT_DURATION * 3;
+export const BLOCK_DURATION = 4;
+
+// Small slashing unit so we don't kick anyone out.
+export const slashingUnit = BigInt(1e14);
+export const slashingQuorum = 3;
+export const slashingRoundSize = 4;
+export const aztecEpochDuration = 2;
+
+/**
+ * The shared per-test slashing config for the offense-detection suites (`duplicate_proposal`,
+ * `duplicate_attestation`). Spread into a {@link MultiNodeTestContext.setup} call alongside
+ * {@link SLASHER_ENABLED_MULTI_VALIDATOR_OPTS} and `initialValidators` (from `buildMockGossipValidators`).
+ */
+export const baseSlashingOpts = {
+  anvilSlotsInAnEpoch: 4,
+  listenAddress: '127.0.0.1',
+  aztecEpochDuration,
+  ethereumSlotDuration: ETHEREUM_SLOT_DURATION,
+  aztecSlotDuration: AZTEC_SLOT_DURATION,
+  aztecTargetCommitteeSize: COMMITTEE_SIZE,
+  aztecProofSubmissionEpochs: 1024, // effectively do not reorg
+  slashInactivityConsecutiveEpochThreshold: 32, // effectively do not slash for inactivity
+  minTxsPerBlock: 0, // always be building
+  slashingQuorum,
+  slashingRoundSizeInEpochs: slashingRoundSize / aztecEpochDuration,
+  slashAmountSmall: slashingUnit,
+  slashAmountMedium: slashingUnit * 2n,
+  slashAmountLarge: slashingUnit * 3n,
+  blockDurationMs: BLOCK_DURATION * 1000,
+  slashDuplicateProposalPenalty: slashingUnit,
+  slashingOffsetInRounds: 1,
+};
+
+/**
+ * The fast slot timing shared by the sentinel-observation suites (`sentinel_status_slash`,
+ * `validators_sentinel`, `multiple_validators_sentinel`, `slash_veto_demo`). Slots are 8s (eth 4s ×
+ * epoch 2), which fit a checkpoint comfortably at the fast mocked-p2p operational budgets used at
+ * eth<8, keeping wall-clock down for tests whose bodies advance through real L2 slots. Spread into a
+ * {@link MultiNodeTestContext.setup} call alongside {@link SLASHER_ENABLED_MULTI_VALIDATOR_OPTS},
+ * `initialValidators`, and the per-test slash/penalty config. Non-sentinel offense-detection files
+ * that only need the same fast timing spread this and override `sentinelEnabled: false`.
+ */
+export const SENTINEL_TIMING = {
+  anvilSlotsInAnEpoch: 4,
+  listenAddress: '127.0.0.1',
+  ethereumSlotDuration: 4,
+  aztecSlotDuration: 8,
+  aztecEpochDuration: 2,
+  sentinelEnabled: true,
+} as const;
+
+/** A single detected slash offense as returned by {@link AztecNodeService.getSlashOffenses}. */
+export type SlashOffense = Awaited<ReturnType<AztecNodeService['getSlashOffenses']>>[number];
+
+/** Looks up the offense recorded for `validator` of `offenseType` at `slot`, if any. */
+export function findSlashOffense(
+  offenses: SlashOffense[],
+  validator: EthAddress,
+  offenseType: OffenseType,
+  slot: SlotNumber,
+): SlashOffense | undefined {
+  return offenses.find(
+    offense =>
+      offense.validator.equals(validator) &&
+      offense.offenseType === offenseType &&
+      offense.epochOrSlot === BigInt(slot),
+  );
+}
+
+export function awaitProposalExecution(
+  slashingProposer: SlashingProposerContract,
+  timeoutSeconds: number,
+  logger: Logger,
+): Promise<bigint> {
+  return testSpan(
+    'wait:slash-execution',
+    () =>
+      new Promise<bigint>((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          logger.warn(`Timed out waiting for proposal execution`);
+          reject(new Error(`Timeout waiting for proposal execution after ${timeoutSeconds}s`));
+        }, timeoutSeconds * 1000);
+
+        const unwatch = slashingProposer.listenToRoundExecuted(args => {
+          logger.warn(`Slash from round ${args.round} executed`);
+          clearTimeout(timeout);
+          unwatch();
+          resolve(args.round);
+        });
+      }),
+  );
+}
+
+export async function awaitCommitteeExists({
+  rollup,
+  logger,
+}: {
+  rollup: RollupContract;
+  logger: Logger;
+}): Promise<readonly `0x${string}`[]> {
+  logger.info(`Waiting for committee to be set`);
+  let committee: EthAddress[] | undefined;
+  await testSpan('wait:committee', () =>
+    retryUntil(
+      async () => {
+        committee = await rollup.getCurrentEpochCommittee();
+        return committee && committee.length > 0;
+      },
+      'non-empty committee',
+      60,
+    ),
+  );
+  logger.warn(`Committee has been formed`, { committee: committee!.map(c => c.toString()) });
+  return committee!.map(c => c.toString() as `0x${string}`);
+}
+
+/**
+ * Scans L2 slots forward from `minLeadSlots` ahead of the current slot, returning the first slot in
+ * which `targetProposer` is the proposer.
+ *
+ * Scanning starts at `currentSlot + minLeadSlots` and only ever moves forward, so every returned slot
+ * is at least `minLeadSlots` ahead — a caller can safely warp to `targetSlot - minLeadSlots` for a
+ * settle buffer without risking a backwards warp. Stepping by a single slot examines both epoch
+ * parities, which matters because the per-slot proposer is a different RANDAO-shuffled committee
+ * member: searching only a fixed offset within each epoch can leave a 1-of-N target unexamined when
+ * the epoch is short. A candidate in an epoch whose committee isn't sampled yet makes the proposer
+ * lookup revert with EpochNotStable; this warps one epoch forward and continues, keeping the
+ * candidate at least `minLeadSlots` ahead of the new current slot. Throws after `maxSlotsToScan`.
+ *
+ * Unlike {@link advanceToEpochBeforeProposer}, this does not stop an epoch early — callers that want
+ * to warp close to the target (rather than stage sequencers an epoch ahead) use this and warp the
+ * final `minLeadSlots` in themselves.
+ */
+export function findUpcomingProposerSlot({
+  epochCache,
+  cheatCodes,
+  targetProposer,
+  logger,
+  minLeadSlots,
+  maxSlotsToScan = 100,
+}: {
+  epochCache: EpochCacheInterface;
+  cheatCodes: RollupCheatCodes;
+  targetProposer: EthAddress;
+  logger: Logger;
+  minLeadSlots: number;
+  maxSlotsToScan?: number;
+}): Promise<SlotNumber> {
+  return testSpan('warp:find-proposer', async () => {
+    let candidate = Number(await cheatCodes.getSlot()) + minLeadSlots;
+
+    for (let scanned = 0; scanned < maxSlotsToScan; scanned++) {
+      let proposer: EthAddress | undefined;
+      try {
+        proposer = await epochCache.getProposerAttesterAddressInSlot(SlotNumber(candidate));
+      } catch (err) {
+        if (!(err instanceof Error) || !err.message.includes('EpochNotStable')) {
+          throw err;
+        }
+        await cheatCodes.advanceToNextEpoch();
+        const newCurrentSlot = Number(await cheatCodes.getSlot());
+        // Keep the lead after the warp: never return a slot we could no longer warp ahead of.
+        candidate = Math.max(candidate, newCurrentSlot + minLeadSlots);
+        continue;
+      }
+
+      if (proposer && proposer.equals(targetProposer)) {
+        logger.warn(`Found target proposer ${targetProposer} at slot ${candidate}`);
+        return SlotNumber(candidate);
+      }
+      candidate++;
+    }
+
+    throw new Error(`Target proposer ${targetProposer} not found within ${maxSlotsToScan} slots`);
+  });
+}
+
+/**
+ * Advance epochs until we find one where the target proposer is selected for a slot at least
+ * `warmupSlots` into the epoch, then stop one epoch before it. This leaves time for the caller to
+ * start sequencers before warping to the target epoch, avoiding the race where the target epoch
+ * passes before sequencers are ready.
+ *
+ * The first `warmupSlots` slots of the epoch are skipped on purpose. Callers warp to one slot
+ * before the target epoch and, under proposer pipelining, the proposer begins building one slot
+ * before its proposal slot. If the proposer were in the first slot of the epoch, that build would
+ * begin at the exact instant of the warp, leaving the freshly-started sequencer no warm-up margin;
+ * it then serializes its (often AVM-heavy) proposal past the slot boundary and honest receivers
+ * reject it as late. Picking a slot at least `warmupSlots` into the epoch guarantees that many full
+ * slots of wall-clock between the warp and the start of the proposer's build.
+ *
+ * Returns the target epoch and the concrete target slot so the caller can warp to it after starting
+ * sequencers.
+ *
+ * The default `maxAttempts` accounts for the worst-case caller: with a 2-slot epoch and
+ * `warmupSlots = 1`, each attempt checks a single slot, and with a 4-member committee the target is
+ * the proposer with probability 1/4 per attempt (proposer index is keccak(epoch, slot, seed) mod
+ * committee size, so attempts are independent). 50 attempts bound the miss probability at
+ * (3/4)^50 ≈ 6e-7; each attempt is just a committee query plus an anvil warp, so the extra headroom
+ * costs almost nothing.
+ */
+export function advanceToEpochBeforeProposer({
+  epochCache,
+  cheatCodes,
+  targetProposer,
+  logger,
+  maxAttempts = 50,
+  warmupSlots = 1,
+}: {
+  epochCache: EpochCacheInterface;
+  cheatCodes: RollupCheatCodes;
+  targetProposer: EthAddress;
+  logger: Logger;
+  maxAttempts?: number;
+  warmupSlots?: number;
+}): Promise<{ targetEpoch: EpochNumber; targetSlot: SlotNumber }> {
+  return testSpan('warp:find-proposer', async () => {
+    const { epochDuration } = await cheatCodes.getConfig();
+
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const currentEpoch = await cheatCodes.getEpoch();
+      // Check the NEXT epoch's slots so we stay one epoch before the target,
+      // giving the caller time to start sequencers before the target epoch arrives.
+      const nextEpoch = Number(currentEpoch) + 1;
+      const epochStartSlot = nextEpoch * Number(epochDuration);
+      // Skip the first `warmupSlots` slots so the caller keeps a warm-up margin after warping to one
+      // slot before the epoch (see the doc comment above).
+      const startSlot = epochStartSlot + warmupSlots;
+      const endSlot = epochStartSlot + Number(epochDuration);
+
+      logger.info(
+        `Checking next epoch ${nextEpoch} (slots ${startSlot}-${endSlot - 1}) for proposer ${targetProposer} (current epoch: ${currentEpoch})`,
+      );
+
+      for (let s = startSlot; s < endSlot; s++) {
+        const proposer = await epochCache.getProposerAttesterAddressInSlot(SlotNumber(s));
+        if (proposer && proposer.equals(targetProposer)) {
+          logger.warn(
+            `Found target proposer ${targetProposer} in slot ${s} of epoch ${nextEpoch}. Staying at epoch ${currentEpoch} to allow sequencer startup.`,
+          );
+          return { targetEpoch: EpochNumber(nextEpoch), targetSlot: SlotNumber(s) };
+        }
+      }
+
+      logger.info(`Target proposer not found in epoch ${nextEpoch}, advancing to next epoch`);
+      await cheatCodes.advanceToNextEpoch();
+    }
+
+    throw new Error(`Target proposer ${targetProposer} not found in any slot after ${maxAttempts} epoch attempts`);
+  });
+}
+
+export async function awaitOffenseDetected({
+  logger,
+  nodeAdmin,
+  slashingRoundSize,
+  epochDuration,
+  waitUntilOffenseCount,
+  timeoutSeconds = 120,
+}: {
+  nodeAdmin: AztecNodeAdmin;
+  logger: Logger;
+  slashingRoundSize: number;
+  epochDuration: number;
+  waitUntilOffenseCount?: number;
+  timeoutSeconds?: number;
+}) {
+  const targetOffenseCount = waitUntilOffenseCount ?? 1;
+  logger.warn(`Waiting for ${pluralize('offense', targetOffenseCount)} to be detected`);
+  const offenses = await testSpan('wait:offense', () =>
+    retryUntil(
+      async () => {
+        const offenses = await nodeAdmin.getSlashOffenses('all');
+        if (offenses.length >= targetOffenseCount) {
+          return offenses;
+        }
+      },
+      'non-empty offenses',
+      timeoutSeconds,
+    ),
+  );
+  logger.info(
+    `Hit ${offenses.length} offenses on rounds ${unique(offenses.map(o => getRoundForOffense(o, { slashingRoundSize, epochDuration })))}`,
+    { offenses },
+  );
+  return offenses;
+}
+
+/**
+ * Await the committee to be slashed out of the validator set.
+ * Currently assumes that the committee is the same size as the validator set.
+ */
+export async function awaitCommitteeKicked({
+  rollup,
+  cheatCodes,
+  committee,
+  slashingProposer,
+  slashingRoundSize,
+  aztecSlotDuration,
+  aztecEpochDuration,
+  logger,
+  offenseEpoch,
+}: {
+  rollup: RollupContract;
+  cheatCodes: RollupCheatCodes;
+  committee: readonly `0x${string}`[];
+  slashingProposer: SlashingProposerContract | undefined;
+  slashingRoundSize: number;
+  aztecSlotDuration: number;
+  aztecEpochDuration: number;
+  logger: Logger;
+  offenseEpoch: number;
+}) {
+  if (!slashingProposer) {
+    throw new Error('No slashing proposer configured. Cannot test slashing.');
+  }
+
+  await testSpan('wait:committee-kicked', async () => {
+    await cheatCodes.debugRollup();
+
+    // Use the slash offset to ensure we are in the right epoch for tally
+    const slashOffsetInRounds = await slashingProposer.getSlashOffsetInRounds();
+    const slashingRoundSizeInEpochs = slashingRoundSize / aztecEpochDuration;
+    const slashingOffsetInEpochs = Number(slashOffsetInRounds) * slashingRoundSizeInEpochs;
+    const firstEpochInOffenseRound = offenseEpoch - (offenseEpoch % slashingRoundSizeInEpochs);
+    const targetEpoch = firstEpochInOffenseRound + slashingOffsetInEpochs;
+    logger.info(`Advancing to epoch ${targetEpoch} so we start slashing`);
+    await cheatCodes.advanceToEpoch(EpochNumber(targetEpoch), { offset: -aztecSlotDuration / 2 });
+
+    const attestersPre = await rollup.getAttesters();
+    expect(attestersPre.length).toBe(committee.length);
+
+    for (const attester of attestersPre) {
+      const attesterInfo = await rollup.getAttesterView(attester);
+      expect(attesterInfo.status).toEqual(1); // Validating
+    }
+
+    // Allow up to four round-lengths so that under proposer pipelining, where individual rounds
+    // sometimes fail to gather quorum because parts of the committee miss votes due to chain-state
+    // races, we still see a later round execute the slash.
+    const timeout = slashingRoundSize * 4 * aztecSlotDuration + 30;
+    logger.info(`Waiting for slash to be executed (timeout ${timeout}s)`);
+    await awaitProposalExecution(slashingProposer, timeout, logger);
+
+    // The attesters should still form the committee but they should be reduced to the "living" status
+    await cheatCodes.debugRollup();
+    const committeePostSlashing = await rollup.getCurrentEpochCommittee();
+    expect(committeePostSlashing?.length).toBe(attestersPre.length);
+
+    const attestersPostSlashing = await rollup.getAttesters();
+    expect(attestersPostSlashing.length).toBe(0);
+
+    for (const attester of attestersPre) {
+      const attesterInfo = await rollup.getAttesterView(attester);
+      expect(attesterInfo.status).toEqual(2); // Living
+    }
+
+    logger.info(`Advancing to check current committee`);
+    await cheatCodes.debugRollup();
+    await cheatCodes.advanceToEpoch(
+      EpochNumber((await cheatCodes.getEpoch()) + (await rollup.getLagInEpochsForValidatorSet()) + 1),
+    );
+    await cheatCodes.debugRollup();
+
+    const committeeNextEpoch = await rollup.getCurrentEpochCommittee();
+    // The committee should be undefined, since the validator set is empty
+    // and the tests currently using this helper always set a target committee size.
+    expect(committeeNextEpoch).toBeUndefined();
+
+    const attestersNextEpoch = await rollup.getAttesters();
+    expect(attestersNextEpoch.length).toBe(0);
+  });
+}
+
+/** Resolves the slot at which `node` includes `txHash`, by reading the tx receipt and block header. */
+export async function getMinedSlot(node: AztecNodeService, txHash: { toString(): string }): Promise<number> {
+  const receipt = await node.getTxReceipt(txHash as any);
+  if (!receipt.blockNumber) {
+    throw new Error(`Tx ${txHash} has no block number on receipt`);
+  }
+  const block = await node.getBlock(receipt.blockNumber);
+  if (!block) {
+    throw new Error(`Block ${receipt.blockNumber} not found`);
+  }
+  return Number(block.header.getSlot());
+}
+
+/**
+ * Submits `numTxs` account-deployment transactions through `node`, paying with the funded hardcoded
+ * account (`context.accounts[0]`). Repoints the context wallet at `node` so the txs land in that node's
+ * mempool. The mock-gossip equivalent of the old `submitTransactions(logger, node, numTxs, fundedAccount)`
+ * helper, which built a fresh wallet from the funded account.
+ */
+export function submitTxsThroughNode(
+  test: MultiNodeTestContext,
+  node: AztecNodeService,
+  numTxs: number,
+): Promise<TxHash[]> {
+  const wallet = test.context.wallet as TestWallet;
+  wallet.updateNode(node);
+  return submitTxsTo(wallet, test.context.accounts[0], numTxs, test.logger);
+}
+
+export { jest };

package/src/p2p/README.md

@@ -0,0 +1,78 @@
+# `p2p` e2e test category
+
+P2P tests run a network of validator nodes over **real libp2p** — a real bootstrap node, discv5
+discovery, the GossipSub mesh, the req/resp protocol, and real peer authentication and transport. This
+is the category for any test whose subject is the networking layer itself: peer discovery and
+rediscovery, gossip mesh formation and propagation, req/resp fetching, preferred-peer / supernode
+topologies, and peer auth gating.
+
+Tests whose subject — proposals, attestations, checkpointing, pruning/recovery, offense detection,
+sentinel observability — is faithfully reproduced by the in-memory `MockGossipSubNetwork` bus belong in
+the `multi-node` category instead, which is far cheaper to run. Only reach for `p2p` when the behavior
+under test genuinely cannot be reproduced without real networking.
+
+## Entrypoint
+
+`P2PNetworkTest` (`p2p_network.ts`) is the env-builder for this category. Unlike `MultiNodeTestContext`,
+it does **not** extend `SingleNodeTestContext`; it is a parallel, self-contained builder that calls the
+root `setup()` directly, then spawns real-libp2p nodes via the factories in
+`../fixtures/setup_p2p_test.ts`. Its distinguishing traits:
+
+- A real bootstrap node (`addBootstrapNode`) with a fixed private key, so nodes discover each other via
+  discv5 and data directories can be reused across a restart.
+- Two validator-registration paths: `applyBaseSetup()` registers the committee post-genesis via the
+  on-chain `MultiAdder` cheat (validators are added at `aztecTargetCommitteeSize: 0`, then activated by
+  warping past the validator-set lag), while tests that exercise the real onboarding flow call
+  `addBootstrapNode()` and register each validator through the CLI `addL1Validator` path instead.
+- `waitForP2PMeshConnectivity(nodes, …)` — waits for peer connections and for the GossipSub mesh to
+  form on the requested topics; callers that need a proposal to reach the whole committee within a slot
+  raise `minMeshPeerCount` for a full mesh.
+- Data-directory management: `setup()` creates one root temp dir; `dataDirFor(label)` hands out a nested
+  per-role path (`createNodes` appends `-<index>`, single-node factories use it verbatim); `teardown()`
+  removes the whole tree in one recursive delete. Test files never `mkdtemp`/`rmSync` themselves.
+- One named timing preset: `SHORTENED_BLOCK_TIME_CONFIG_NO_PRUNES` (ethSlot 4s, aztecSlot 12s,
+  `aztecProofSubmissionEpochs: 640` so the chain effectively never prunes), used by every file with
+  per-file slot/epoch overrides. `WAIT_FOR_TX_TIMEOUT` derives from the env slot duration.
+
+## Shared skeleton and helpers
+
+`shared.ts` holds the common scenario skeleton and the reusable building blocks, so test bodies read
+declaratively rather than re-deriving the same ~40 lines of node-creation / mesh-wait / signer-check
+boilerplate:
+
+- `runGossipScenario(opts)` — the shared bootstrap→createNodes→mesh→account→(submit)→verify skeleton.
+  Each varying part is a callback/flag: validator registration (`beforeCreateNodes`), extra prover /
+  monitor nodes (`createExtraNodes`), pre-submit waits (`beforeSubmit`), mesh parameters (`mesh`),
+  whether/how many txs to submit (`txsPerNode`, `submitSequentially`), which published checkpoint to
+  read signers from (`checkpointSource`), and scenario-specific verification (`afterVerify`).
+- `verifyAttestationSigners(t, nodes, checkpoint)` — recovers the attestation signers from a published
+  checkpoint and asserts each belongs to the validator set; returns the signers for extra assertions.
+- `getPublishedCheckpointForTx(node, txHash)` / `waitForFirstPublishedCheckpoint(t, nodes)` — resolve
+  the published checkpoint to read signers from, either from a mined tx's block or by polling for the
+  first one indexed by the archiver.
+- `waitForNodesToSync(t, nodes)` — wait for every node to catch up to the initial node's tip.
+- `maybeCheckQosAlerts(logger)` — run the QoS Grafana alert check when `CHECK_ALERTS=true`, else a no-op.
+- `submitTransactions` / `submitComplexTxsTo` / `prepareTransactions` — build a throwaway wallet on a
+  node and submit (or pre-prove) N txs through it.
+
+Node factories live in `../fixtures/setup_p2p_test.ts` (`createNodes`, `createNode`,
+`createNonValidatorNode`, `createProverNode`, `createValidatorConfig`, `generatePrivateKeys`), shared
+with `P2PNetworkTest`.
+
+## Organizing principle
+
+Each file is one real-libp2p scenario the mock-gossip bus cannot reproduce, with a single top-level
+`describe` named `e2e_p2p_*`. Files are plain `*.test.ts` (no `.parallel` suffix): each is one CI
+container running the whole file. Because the nodes bind **fixed UDP/TCP ports**, two p2p test files
+must never run at the same time — run them one at a time locally.
+
+## Files
+
+| File | Scenario |
+|---|---|
+| `gossip_network.test.ts` | The baseline gossip test, two describes on the shared skeleton: `cheat-registered validators` (4 validators + a p2p-only prover + a re-execution monitor; txs mine from every node, attestation signers match the committee, and the prover produces a proven block by collecting txs over p2p) and `on-chain-registered validators (no cheats)` (validators registered via the real `addL1Validator` CLI path with a ZkPassport mock proof, then the same propagation/signer checks). |
+| `fee_asset_price_oracle_gossip.test.ts` | A fee-asset price set on a mock L1 `StateView` contract gossips through the validator network and the rollup's on-chain price converges on it across two adjustments. Runs on the shared skeleton with `txsPerNode: 0` — no txs are submitted; empty blocks carry the price. |
+| `late_prover_tx_collection.test.ts` | A prover that joins after a block was already mined learns the block from its archiver (via L1 sync) but is missing the txs, and must fetch them from peers over the req/resp `BLOCK_TXS` path — the same path `ProverNode.gatherTxs` takes when preparing an epoch proof. |
+| `preferred_gossip_network.test.ts` | A preferred-node (supernode) topology: preferred nodes accept only validator connections, a no-discovery validator reaches the network exclusively through them, and gossip monitors assert traffic flows only through the expected peers. Verifies exact per-role peer counts, tx mining, and attestation signers. |
+| `rediscovery.test.ts` | Nodes form a mesh, then the bootstrap node and all validators are stopped and restarted from their data directories with no bootstrap ENR — they rejoin purely from the discv5 peer tables they persisted to disk. |
+| `reqresp/reqresp.test.ts` | Tx gossip is disabled on the upcoming proposer nodes, so they must request the missing tx data over req/resp before they can attest; also asserts a multiple-blocks-per-slot checkpoint is produced with correctly ordered blocks. The scenario body lives in `reqresp/utils.ts`. |

package/src/{e2e_p2p → p2p}/p2p_network.ts

@@ -25,7 +25,10 @@ import type { GenesisData } from '@aztec/stdlib/world-state';
 import { ZkPassportProofParams } from '@aztec/stdlib/zkpassport';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
+import fs from 'fs';
 import getPort from 'get-port';
+import os from 'os';
+import path from 'path';
 import { type GetContractReturnType, getAddress, getContract } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 
@@ -46,6 +49,7 @@ import {
   createValidatorConfig,
   generatePrivateKeys,
 } from '../fixtures/setup_p2p_test.js';
+import { getStandardContractGenesisNullifiers } from '../fixtures/standard_contracts_genesis.js';
 import { getEndToEndTestTelemetryClient } from '../fixtures/with_telemetry_utils.js';
 import type { TestWallet } from '../test-wallet/test_wallet.js';
 
@@ -84,6 +88,9 @@ export class P2PNetworkTest {
 
   public bootstrapNode?: BootstrapNode;
 
+  // Root temp directory holding every node's data dir. Created in setup(), removed in teardown().
+  public dataDir!: string;
+
   // Store setup options for use in setup()
   private setupOptions: SetupOptions;
   private deployL1ContractsArgs: any;
@@ -194,6 +201,19 @@ export class P2PNetworkTest {
     return this.hardcodedAccountData;
   }
 
+  /**
+   * Returns a per-role data directory nested under this test's root data dir. The multi-node factories
+   * (`createNodes`) append `-<index>` to this base for each node they spawn; single-node factories
+   * (`createProverNode`, `createNonValidatorNode`, `createNode`) use it verbatim. Everything lives under
+   * `this.dataDir`, so a single recursive remove in teardown() cleans up all of it.
+   */
+  dataDirFor(label: string): string {
+    if (!this.dataDir) {
+      throw new Error('Call setup to initialize the data directory.');
+    }
+    return path.join(this.dataDir, label);
+  }
+
   async addBootstrapNode() {
     this.logger.info('Adding bootstrap node');
     const telemetry = await getEndToEndTestTelemetryClient(this.metricsPort);
@@ -356,6 +376,8 @@ export class P2PNetworkTest {
   async setup() {
     this.logger.info('Setting up subsystems from fresh');
 
+    this.dataDir = fs.mkdtempSync(path.join(os.tmpdir(), `${this.testName}-`));
+
     // Pre-compute hardcoded account data so it gets funded in genesis.
     const contract = new SchnorrHardcodedKeyAccountContract();
     const secret = Fr.random();
@@ -394,6 +416,7 @@ export class P2PNetworkTest {
       undefined,
       undefined,
       this.context.genesis!.genesisTimestamp,
+      await getStandardContractGenesisNullifiers(),
     );
     this.genesis = genesis;
 
@@ -431,6 +454,7 @@ export class P2PNetworkTest {
     timeoutSeconds = 30,
     checkIntervalSeconds = 0.1,
     topics: TopicType[] = [TopicType.tx],
+    minMeshPeerCount = 1,
   ) {
     const nodeCount = expectedNodeCount ?? nodes.length;
     const minPeerCount = nodeCount - 1;
@@ -457,11 +481,13 @@ 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.
+    // Wait for the GossipSub mesh to form for all specified topics. By default we only require at
+    // least 1 mesh peer per node, since GossipSub stops grafting once it reaches Dlo peers and won't
+    // fill the mesh to every available peer. Callers that need a proposal to reach the whole
+    // committee within a slot (e.g. quorum-from-genesis tests) raise `minMeshPeerCount` so the mesh
+    // is fully formed — a single mesh peer can leave some committee members unreached at first.
     for (const topic of topics) {
-      this.logger.warn(`Waiting for GossipSub mesh to form for ${topic} topic...`);
+      this.logger.warn(`Waiting for GossipSub mesh (>= ${minMeshPeerCount} peers per node) for ${topic} topic...`);
       await Promise.all(
         nodes.map(async (node, index) => {
           const p2p = node.getP2P();
@@ -469,15 +495,15 @@ export class P2PNetworkTest {
             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;
+              return meshPeers >= minMeshPeerCount ? true : undefined;
             },
-            `Node ${index} to have gossip mesh peers for ${topic} topic`,
+            `Node ${index} to have >= ${minMeshPeerCount} gossip mesh peers for ${topic} topic`,
             timeoutSeconds,
             checkIntervalSeconds,
           );
         }),
       );
-      this.logger.warn(`All nodes have gossip mesh peers for ${topic} topic`);
+      this.logger.warn(`All nodes have >= ${minMeshPeerCount} gossip mesh peers for ${topic} topic`);
     }
   }
 
@@ -485,6 +511,9 @@ export class P2PNetworkTest {
     await this.monitor.stop();
     await tryStop(this.bootstrapNode, this.logger);
     await teardown(this.context);
+    if (this.dataDir) {
+      fs.rmSync(this.dataDir, { recursive: true, force: true, maxRetries: 3 });
+    }
   }
 
   async getContracts(): Promise<{