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

package/src/multi-node/multi_node_test_context.ts

@@ -0,0 +1,447 @@
+import type { AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
+import { EthAddress } from '@aztec/aztec.js/addresses';
+import { Fr } from '@aztec/aztec.js/fields';
+import { RollupContract, type SlashingProposerContract } from '@aztec/ethereum/contracts';
+import type { Operator } from '@aztec/ethereum/deploy-aztec-l1-contracts';
+import type { ViemClient } from '@aztec/ethereum/types';
+import { CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { times } from '@aztec/foundation/collection';
+import { SecretValue } from '@aztec/foundation/config';
+import { retryUntil } from '@aztec/foundation/retry';
+import { bufferToHex } from '@aztec/foundation/string';
+import { SlasherAbi } from '@aztec/l1-artifacts';
+import type { L2Tips } from '@aztec/stdlib/block';
+import type { AztecNode, BlockResponse } from '@aztec/stdlib/interfaces/client';
+import type { Offense } from '@aztec/stdlib/slashing';
+import { createSharedSlashingProtectionDb } from '@aztec/validator-ha-signer/factory';
+import type { SlashingProtectionDatabase } from '@aztec/validator-ha-signer/types';
+
+import { type GetContractReturnType, getAddress, getContract } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+
+import { testSpan } from '../fixtures/timing.js';
+import { getPrivateKeyFromIndex } from '../fixtures/utils.js';
+import { NO_REORG_SUBMISSION_EPOCHS } from '../single-node/setup.js';
+import {
+  SingleNodeTestContext,
+  type SingleNodeTestOpts,
+  type TrackedSequencerEvent,
+} from '../single-node/single_node_test_context.js';
+
+export { NO_REORG_SUBMISSION_EPOCHS, PROVING_SLOT_TIMING } from '../single-node/setup.js';
+export {
+  WORLD_STATE_CHECKPOINT_HISTORY,
+  WORLD_STATE_BLOCK_CHECK_INTERVAL,
+  ARCHIVER_POLL_INTERVAL,
+  DEFAULT_L1_BLOCK_TIME,
+  REORG_TIMING_BASE,
+  FAST_REORG_TIMING,
+  MULTI_VALIDATOR_REORG_TIMING,
+  MULTI_VALIDATOR_BLOCK_PRODUCTION_TIMING,
+  WIDE_SLOT_TIMING,
+  type BlockProposedEvent,
+  type TrackedSequencerEvent,
+  type SingleNodeTestOpts,
+} from '../single-node/single_node_test_context.js';
+
+/** Options for {@link MultiNodeTestContext.setup} — superset of {@link SingleNodeTestOpts}. */
+export type MultiNodeTestOpts = SingleNodeTestOpts;
+
+/** A registered validator with its on-chain operator data and the L1 private key its node signs with. */
+export type RegisteredValidator = Operator & { privateKey: `0x${string}` };
+
+/**
+ * Builds the deterministic validator set used across the multi-validator tests: `count` validators
+ * keyed from `getPrivateKeyFromIndex(i + 3)` (indices 0..2 are reserved for the setup account,
+ * bootstrap node, and prover node, matching the `P2PNetworkTest` convention). This replaces the
+ * `times(N, i => ({ attester, withdrawer, privateKey, bn254SecretKey }))` block copy-pasted in every
+ * direct multi-validator test.
+ */
+export function buildMockGossipValidators(count: number): RegisteredValidator[] {
+  return times(count, i => {
+    const privateKey = bufferToHex(getPrivateKeyFromIndex(i + 3)!);
+    const attester = EthAddress.fromString(privateKeyToAccount(privateKey).address);
+    return { attester, withdrawer: attester, privateKey, bn254SecretKey: new SecretValue(Fr.random().toBigInt()) };
+  });
+}
+
+/**
+ * The shared `setup` cluster for the multi-validator tests that run a tight committee on the
+ * in-memory mock-gossip bus without a prover (block-production / recovery tests). Spread into the `setup`
+ * call alongside `initialValidators` (from {@link buildMockGossipValidators}). Tests that want a
+ * prover (MBPS / HA-sync) leave `startProverNode` explicit rather than adopting this preset's `false`.
+ */
+export const MOCK_GOSSIP_MULTI_VALIDATOR_OPTS = {
+  mockGossipSubNetwork: true,
+  skipInitialSequencer: true,
+  startProverNode: false,
+  aztecProofSubmissionEpochs: NO_REORG_SUBMISSION_EPOCHS,
+  numberOfAccounts: 0,
+} as const;
+
+/**
+ * The `setup` preset for a slasher-enabled committee on the in-memory mock-gossip bus, used by the
+ * offense-detection tests (`slashing/`). Mirrors {@link MOCK_GOSSIP_MULTI_VALIDATOR_OPTS} but turns
+ * the slasher on; spread alongside `initialValidators` (from {@link buildMockGossipValidators}) and
+ * the per-test slashing-round/penalty config.
+ */
+export const SLASHER_ENABLED_MULTI_VALIDATOR_OPTS = {
+  mockGossipSubNetwork: true,
+  skipInitialSequencer: true,
+  slasherEnabled: true,
+} as const;
+
+/** The slasher and slashing-proposer L1 contracts a slashing test interacts with. */
+export type SlashingContracts = {
+  rollup: RollupContract;
+  slasherContract: GetContractReturnType<typeof SlasherAbi, ViemClient>;
+  slashingProposer: SlashingProposerContract | undefined;
+};
+
+/** The per-offense penalty knobs a slashing test tunes; all default to a single `unit`. */
+export type SlashingPenalties = {
+  slashInactivityPenalty: bigint;
+  slashDataWithholdingPenalty: bigint;
+  slashBroadcastedInvalidBlockPenalty: bigint;
+  slashBroadcastedInvalidCheckpointProposalPenalty: bigint;
+  slashDuplicateProposalPenalty: bigint;
+  slashDuplicateAttestationPenalty: bigint;
+  slashProposeInvalidAttestationsPenalty: bigint;
+  slashProposeDescendantOfCheckpointWithInvalidAttestationsPenalty: bigint;
+  slashAttestInvalidCheckpointProposalPenalty: bigint;
+  slashUnknownPenalty: bigint;
+};
+
+/** The names of every per-offense penalty knob, in declaration order. */
+const SLASHING_PENALTY_KEYS: (keyof SlashingPenalties)[] = [
+  'slashInactivityPenalty',
+  'slashDataWithholdingPenalty',
+  'slashBroadcastedInvalidBlockPenalty',
+  'slashBroadcastedInvalidCheckpointProposalPenalty',
+  'slashDuplicateProposalPenalty',
+  'slashDuplicateAttestationPenalty',
+  'slashProposeInvalidAttestationsPenalty',
+  'slashProposeDescendantOfCheckpointWithInvalidAttestationsPenalty',
+  'slashAttestInvalidCheckpointProposalPenalty',
+  'slashUnknownPenalty',
+];
+
+/**
+ * Returns every per-offense slashing penalty set to `unit` (default `1e14` — small enough not to
+ * kick a validator out). Spread alongside the slashing-round/quorum config in a slashing test's
+ * `setup`.
+ */
+export function defaultSlashingPenalties(unit: bigint = BigInt(1e14)): SlashingPenalties {
+  return Object.fromEntries(SLASHING_PENALTY_KEYS.map(key => [key, unit])) as SlashingPenalties;
+}
+
+/**
+ * Returns the penalties with only `offense` set to `unit` and every other offense zeroed out, so a
+ * test isolates a single slashing offense. Names the test's intent (which offense is under test) and
+ * replaces the ~9-line manual zero-out block.
+ */
+export function withOnlyOffense(offense: keyof SlashingPenalties, unit: bigint = BigInt(1e14)): SlashingPenalties {
+  return Object.fromEntries(SLASHING_PENALTY_KEYS.map(key => [key, key === offense ? unit : 0n])) as SlashingPenalties;
+}
+
+/** One HA pair: its two member nodes, the two shared validator keys, and the per-node coinbases. */
+export type HaPairNodes = {
+  nodes: [AztecNodeService, AztecNodeService];
+  privateKeys: [`0x${string}`, `0x${string}`];
+  coinbases: [EthAddress, EthAddress];
+};
+
+/**
+ * Stands up two HA pairs from the first four registered validators: nodes[0]/nodes[1] share keys
+ * pk1+pk2, nodes[2]/nodes[3] share pk3+pk4. Each pair shares an in-memory slashing-protection DB (so
+ * only one peer signs per duty) and each node gets a distinct coinbase. Encapsulates the ~40-line
+ * pair-wiring duplicated by both HA tests; the per-test divergence (publishing disabled vs. enabled,
+ * empty-checkpoint building) is passed through `baseOpts`.
+ * @returns The four nodes flat, plus the two `HaPairNodes` descriptors.
+ */
+export async function setupHaPairs(
+  test: MultiNodeTestContext,
+  validators: RegisteredValidator[],
+  opts: { baseOpts?: Partial<AztecNodeConfig> & { dontStartSequencer?: boolean }; coinbases?: EthAddress[] } = {},
+): Promise<{ nodes: AztecNodeService[]; pairs: [HaPairNodes, HaPairNodes] }> {
+  const baseOpts = opts.baseOpts ?? {};
+  const coinbases = opts.coinbases ?? [1, 2, 3, 4].map(n => EthAddress.fromNumber(n));
+  const [pk1, pk2, pk3, pk4] = validators.map(v => v.privateKey);
+  const sharedDb1 = await createSharedSlashingProtectionDb(test.context.dateProvider);
+  const sharedDb2 = await createSharedSlashingProtectionDb(test.context.dateProvider);
+
+  const nodes = [
+    await test.createValidatorNode([pk1, pk2], {
+      ...baseOpts,
+      coinbase: coinbases[0],
+      slashingProtectionDb: sharedDb1,
+    }),
+    await test.createValidatorNode([pk1, pk2], {
+      ...baseOpts,
+      coinbase: coinbases[1],
+      slashingProtectionDb: sharedDb1,
+    }),
+    await test.createValidatorNode([pk3, pk4], {
+      ...baseOpts,
+      coinbase: coinbases[2],
+      slashingProtectionDb: sharedDb2,
+    }),
+    await test.createValidatorNode([pk3, pk4], {
+      ...baseOpts,
+      coinbase: coinbases[3],
+      slashingProtectionDb: sharedDb2,
+    }),
+  ];
+
+  const pairs: [HaPairNodes, HaPairNodes] = [
+    { nodes: [nodes[0], nodes[1]], privateKeys: [pk1, pk2], coinbases: [coinbases[0], coinbases[1]] },
+    { nodes: [nodes[2], nodes[3]], privateKeys: [pk3, pk4], coinbases: [coinbases[2], coinbases[3]] },
+  ];
+
+  return { nodes, pairs };
+}
+
+/**
+ * Multi-validator test base: N validator nodes sharing the in-memory `MockGossipSubNetwork` bus, with
+ * fast block times and short epochs. Extends {@link SingleNodeTestContext} with validator-node
+ * spawning and the convergence helpers (`waitForAllNodes*`, `findSlotsWithProposers`) that only make
+ * sense across a committee. The environment, prover lifecycle, and reorg/proving waiters live on the
+ * parent so the single-node-topology tests share them.
+ */
+export class MultiNodeTestContext extends SingleNodeTestContext {
+  /**
+   * The validators registered on-chain at genesis (from `opts.initialValidators`). Tests spawn nodes
+   * for whichever validators they want online via {@link createValidatorNodeAt}; the rest stay
+   * registered-but-offline. Empty for single-validator-less topologies.
+   */
+  public validators: RegisteredValidator[] = [];
+
+  public override async setup(opts: MultiNodeTestOpts = {}) {
+    this.validators = (opts.initialValidators as RegisteredValidator[] | undefined) ?? [];
+    await super.setup(opts);
+  }
+
+  public createValidatorNode(
+    privateKeys: `0x${string}`[],
+    opts: Partial<AztecNodeConfig> & {
+      dontStartSequencer?: boolean;
+      slashingProtectionDb?: SlashingProtectionDatabase;
+    } = {},
+  ) {
+    this.logger.warn('Creating and syncing a validator node...');
+    return this.createNode({ ...opts, disableValidator: false, validatorPrivateKeys: new SecretValue(privateKeys) });
+  }
+
+  /** Returns the validator registered at on-chain index `index` (0-based into {@link validators}). */
+  public validatorAt(index: number): RegisteredValidator {
+    return this.validators[index];
+  }
+
+  /** The L1 attester address of the validator registered at `index`. */
+  public addressAt(index: number): EthAddress {
+    return this.validators[index].attester;
+  }
+
+  /** The L1 signing key of the validator registered at `index`. */
+  public privateKeyAt(index: number): `0x${string}` {
+    return this.validators[index].privateKey;
+  }
+
+  /**
+   * Spawns a validator node on the mock-gossip bus signing with the validator registered at `index`.
+   * Pass the same `index` to two calls (with different `coinbase`) to model an equivocating proposer
+   * that shares a key across two nodes.
+   */
+  public createValidatorNodeAt(
+    index: number,
+    opts: Partial<AztecNodeConfig> & { dontStartSequencer?: boolean } = {},
+  ): Promise<AztecNodeService> {
+    return this.createValidatorNode([this.privateKeyAt(index)], opts);
+  }
+
+  /** Resolves the rollup, slasher, and slashing-proposer L1 contracts a slashing test interacts with. */
+  public async getSlashingContracts(): Promise<SlashingContracts> {
+    const rollup = this.rollup;
+    const slasherContract = getContract({
+      address: getAddress((await rollup.getSlasherAddress()).toString()),
+      abi: SlasherAbi,
+      client: this.l1Client,
+    });
+    const slashingProposer = await rollup.getSlashingProposer();
+    return { rollup, slasherContract, slashingProposer };
+  }
+
+  /**
+   * Polls every node until `predicate(tips, node)` holds for all of them. The multi-node
+   * generalization of {@link SingleNodeTestContext.waitForNodeToSync} — replaces hand-rolled
+   * `Promise.all(this.nodes.map(node => retryUntil(...)))` fan-out blocks.
+   * @param nodes - Nodes to poll; defaults to all validator nodes (`this.nodes`).
+   */
+  public async waitForAllNodes(
+    predicate: (tips: L2Tips, node: AztecNode) => boolean | Promise<boolean>,
+    opts: { nodes?: AztecNode[]; timeout?: number; interval?: number; description?: string } = {},
+  ): Promise<void> {
+    const nodes = opts.nodes ?? this.nodes;
+    const timeout = opts.timeout ?? this.L2_SLOT_DURATION_IN_S * 4;
+    const interval = opts.interval ?? 0.5;
+    const description = opts.description ?? 'all nodes to reach target';
+    await Promise.all(
+      nodes.map((node, idx) =>
+        retryUntil(
+          async () => {
+            const tips = await node.getChainTips();
+            return (await predicate(tips, node)) || undefined;
+          },
+          `node ${idx} ${description}`,
+          timeout,
+          interval,
+        ),
+      ),
+    );
+  }
+
+  /** Waits until every node's proven checkpoint tip reaches `target`. */
+  public waitForAllNodesToReachProvenCheckpoint(
+    target: CheckpointNumber,
+    opts: { nodes?: AztecNode[]; timeout?: number; interval?: number } = {},
+  ): Promise<void> {
+    return testSpan('wait:proven-checkpoint', () =>
+      this.waitForAllNodes(tips => tips.proven.checkpoint.number >= target, {
+        ...opts,
+        description: `proven checkpoint >= ${target}`,
+      }),
+    );
+  }
+
+  /** Waits until every node's checkpointed checkpoint tip reaches `target`. */
+  public waitForAllNodesToReachCheckpoint(
+    target: CheckpointNumber,
+    opts: { nodes?: AztecNode[]; timeout?: number; interval?: number } = {},
+  ): Promise<void> {
+    return testSpan('wait:checkpoint', () =>
+      this.waitForAllNodes(tips => tips.checkpointed.checkpoint.number >= target, {
+        ...opts,
+        description: `checkpointed checkpoint >= ${target}`,
+      }),
+    );
+  }
+
+  /**
+   * Waits until every node's `proposed` or `checkpointed` tip points at a block whose slot
+   * satisfies `match` (defaults to "slot equals `slot`"). Polls the block referenced by the tip.
+   */
+  public waitForAllNodesToReachBlockAtSlot(
+    slot: SlotNumber,
+    tag: 'proposed' | 'checkpointed',
+    match: (block: BlockResponse) => boolean = block => block.header.globalVariables.slotNumber === slot,
+    opts: { nodes?: AztecNode[]; timeout?: number; interval?: number } = {},
+  ): Promise<void> {
+    return testSpan('wait:block', () =>
+      this.waitForAllNodes(
+        async (tips, node) => {
+          const blockNumber = tag === 'proposed' ? tips.proposed.number : tips.checkpointed.block.number;
+          if (blockNumber === 0) {
+            return false;
+          }
+          const block = await node.getBlock(blockNumber);
+          return !!block && match(block);
+        },
+        { ...opts, description: `${tag} block at slot ${slot}` },
+      ),
+    );
+  }
+
+  /**
+   * Finds `count` consecutive slots (starting from `opts.fromSlot` or the current slot plus a
+   * margin) whose proposers satisfy `predicate`, warping the L1 clock forward one epoch and
+   * retrying when the rollup reports `ValidatorSelection__EpochNotStable` for a future epoch.
+   * Returns the matched slots and their proposer addresses. Encapsulates the slot-search loop
+   * duplicated across the multi-validator tests.
+   */
+  public findSlotsWithProposers(
+    count: number,
+    predicate: (proposers: EthAddress[]) => boolean,
+    opts: { fromSlot?: SlotNumber; margin?: number; maxAttempts?: number } = {},
+  ): Promise<{ slots: SlotNumber[]; proposers: EthAddress[] }> {
+    return testSpan('warp:find-proposer', async () => {
+      const margin = opts.margin ?? 4;
+      const maxAttempts = opts.maxAttempts ?? 200;
+      let candidate = opts.fromSlot ?? SlotNumber(Number(this.epochCache.getEpochAndSlotNow().slot) + margin);
+
+      for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        try {
+          const slots = Array.from({ length: count }, (_, i) => SlotNumber(candidate + i));
+          const maybeProposers = await Promise.all(
+            slots.map(slot => this.epochCache.getProposerAttesterAddressInSlot(slot)),
+          );
+          if (maybeProposers.every((p): p is EthAddress => p !== undefined) && predicate(maybeProposers)) {
+            return { slots, proposers: maybeProposers };
+          }
+          candidate = SlotNumber(candidate + 1);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          if (!msg.includes('EpochNotStable')) {
+            throw err;
+          }
+          const block = await this.l1Client.getBlock({ includeTransactions: false });
+          const warpBy = this.epochDuration * this.L2_SLOT_DURATION_IN_S;
+          const newTs = Number(block.timestamp) + warpBy;
+          this.logger.warn(
+            `Hit EpochNotStable at candidate ${candidate}, warping L1 forward by ${warpBy}s to ${newTs}`,
+          );
+          await this.context.cheatCodes.eth.warp(newTs, { resetBlockInterval: true });
+          const newCurrentSlot = Number(this.epochCache.getEpochAndSlotNow().slot);
+          if (candidate < newCurrentSlot + margin) {
+            candidate = SlotNumber(newCurrentSlot + margin);
+          }
+        }
+      }
+      throw new Error(
+        `Could not find ${count} consecutive slots matching the proposer predicate after ${maxAttempts} attempts`,
+      );
+    });
+  }
+
+  /**
+   * Watches the sequencers of `nodes` via {@link SingleNodeTestContext.watchSequencerEvents}, pulling
+   * the {@link SequencerClient} off each node first. `getMetadata` tags each captured event; it
+   * defaults to `{ validator: this.validators[i].attester }`. Pass an override for tests that label
+   * their nodes differently (e.g. `['A','B','C'][i]`).
+   */
+  public watchNodeSequencerEvents(
+    nodes: AztecNodeService[],
+    getMetadata: (i: number) => Record<string, any> = i => ({ validator: this.validators[i].attester }),
+  ): { failEvents: TrackedSequencerEvent[]; stateChanges: TrackedSequencerEvent[] } {
+    return this.watchSequencerEvents(this.getSequencers(nodes), getMetadata);
+  }
+
+  /**
+   * Waits until matching slash offenses have converged across `nodes`, polling `getSlashOffenses`.
+   * With `opts.mode === 'all'` (the default) every node must record a matching offense; with `'any'`
+   * a single node suffices. Resolves with all matching offenses collected across the polled nodes.
+   */
+  public waitForOffenseOnNodes(
+    nodes: AztecNodeService[],
+    match: (offense: Offense) => boolean,
+    opts: { mode?: 'all' | 'any'; timeout?: number; interval?: number } = {},
+  ): Promise<Offense[]> {
+    const mode = opts.mode ?? 'all';
+    const timeout = opts.timeout ?? this.L2_SLOT_DURATION_IN_S * 4;
+    const interval = opts.interval ?? 0.5;
+    return testSpan('wait:offense', () =>
+      retryUntil(
+        async () => {
+          const perNode = await Promise.all(
+            nodes.map(node => node.getSlashOffenses('all').then(os => os.filter(match))),
+          );
+          const converged =
+            mode === 'all' ? perNode.every(matches => matches.length > 0) : perNode.some(m => m.length > 0);
+          return converged ? perNode.flat() : undefined;
+        },
+        `offense on ${mode} node(s)`,
+        timeout,
+        interval,
+      ),
+    );
+  }
+}

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

@@ -0,0 +1,139 @@
+import type { AztecNodeService } from '@aztec/aztec-node';
+import type { EthAddress } from '@aztec/aztec.js/addresses';
+import { EpochNumber } from '@aztec/foundation/branded-types';
+
+import {
+  MultiNodeTestContext,
+  SLASHER_ENABLED_MULTI_VALIDATOR_OPTS,
+  buildMockGossipValidators,
+} from '../multi_node_test_context.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 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 = 8;
+
+/** Stateful fixture for the inactivity-slash suites: a slasher-enabled committee on the mock-gossip bus. */
+export class InactivityTest {
+  public test!: MultiNodeTestContext;
+  public nodes!: AztecNodeService[];
+  public activeNodes!: AztecNodeService[];
+  public inactiveNodes!: AztecNodeService[];
+  public offlineValidators!: EthAddress[];
+
+  private inactiveNodeCount: number;
+
+  constructor(opts: { inactiveNodeCount: number }) {
+    this.inactiveNodeCount = opts.inactiveNodeCount;
+  }
+
+  static async setup(opts: {
+    slashInactivityConsecutiveEpochThreshold: number;
+    inactiveNodeCount: number;
+  }): Promise<InactivityTest> {
+    const inactivityTest = new InactivityTest(opts);
+    await inactivityTest.run(opts);
+    return inactivityTest;
+  }
+
+  private async run(opts: { slashInactivityConsecutiveEpochThreshold: number; inactiveNodeCount: number }) {
+    this.test = await MultiNodeTestContext.setup({
+      ...SLASHER_ENABLED_MULTI_VALIDATOR_OPTS,
+      inboxLag: 2,
+      anvilSlotsInAnEpoch: 4,
+      // A fake prover node is started by the context (realProofs:false); give it the multi-epoch
+      // proving delay the inactivity scenario relied on, and keep enough broker history.
+      proverNodeConfig: { proverNodeEpochProvingDelayMs: AZTEC_SLOT_DURATION * 1000 },
+      proverBrokerMaxEpochsToKeepResultsFor: 20,
+      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,
+      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,
+      slashInactivityConsecutiveEpochThreshold: opts.slashInactivityConsecutiveEpochThreshold,
+      slashInactivityPenalty: SLASHING_AMOUNT,
+      initialValidators: buildMockGossipValidators(NUM_VALIDATORS),
+    });
+
+    const { rollup } = await this.test.getSlashingContracts();
+    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);
+
+    // Create all active nodes (running sequencer) plus the inactive ones (sequencer disabled).
+    const activeCount = NUM_NODES - this.inactiveNodeCount;
+    this.activeNodes = await Promise.all(
+      Array.from({ length: activeCount }, (_, i) => this.test.createValidatorNodeAt(i)),
+    );
+    this.inactiveNodes = await Promise.all(
+      Array.from({ length: this.inactiveNodeCount }, (_, i) =>
+        this.test.createValidatorNodeAt(activeCount + i, { dontStartSequencer: true }),
+      ),
+    );
+
+    this.nodes = [...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(v => v.attester);
+
+    this.test.logger.warn(`Setup complete. Offline validators are ${this.offlineValidators.join(', ')}.`, {
+      validators: this.test.validators,
+      offlineValidators: this.offlineValidators,
+    });
+
+    this.test.logger.warn(`Advancing to epoch ${SETUP_EPOCH_DURATION - 1} (slashing will start after it is completed)`);
+    await this.test.context.cheatCodes.rollup.advanceToEpoch(EpochNumber(SETUP_EPOCH_DURATION - 1));
+  }
+
+  public async teardown() {
+    await this.test.teardown();
+  }
+
+  public get rollup() {
+    return this.test.rollup;
+  }
+
+  public get logger() {
+    return this.test.logger;
+  }
+
+  public get config() {
+    return this.test.context.config;
+  }
+
+  public get monitor() {
+    return this.test.monitor;
+  }
+
+  public get slashingAmount() {
+    return SLASHING_AMOUNT;
+  }
+}