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

package/dest/multi-node/multi_node_test_context.js

@@ -0,0 +1,347 @@
+import { EthAddress } from '@aztec/aztec.js/addresses';
+import { Fr } from '@aztec/aztec.js/fields';
+import { 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 { createSharedSlashingProtectionDb } from '@aztec/validator-ha-signer/factory';
+import { 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 } 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 } from '../single-node/single_node_test_context.js';
+/**
+ * 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) {
+    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
+};
+/**
+ * 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
+};
+/** The names of every per-offense penalty knob, in declaration order. */ const SLASHING_PENALTY_KEYS = [
+    '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(1e14)) {
+    return Object.fromEntries(SLASHING_PENALTY_KEYS.map((key)=>[
+            key,
+            unit
+        ]));
+}
+/**
+ * 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, unit = BigInt(1e14)) {
+    return Object.fromEntries(SLASHING_PENALTY_KEYS.map((key)=>[
+            key,
+            key === offense ? unit : 0n
+        ]));
+}
+/**
+ * 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, validators, opts = {}) {
+    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 = [
+        {
+            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.
+   */ validators = [];
+    async setup(opts = {}) {
+        this.validators = opts.initialValidators ?? [];
+        await super.setup(opts);
+    }
+    createValidatorNode(privateKeys, opts = {}) {
+        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}). */ validatorAt(index) {
+        return this.validators[index];
+    }
+    /** The L1 attester address of the validator registered at `index`. */ addressAt(index) {
+        return this.validators[index].attester;
+    }
+    /** The L1 signing key of the validator registered at `index`. */ privateKeyAt(index) {
+        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.
+   */ createValidatorNodeAt(index, opts = {}) {
+        return this.createValidatorNode([
+            this.privateKeyAt(index)
+        ], opts);
+    }
+    /** Resolves the rollup, slasher, and slashing-proposer L1 contracts a slashing test interacts with. */ async getSlashingContracts() {
+        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`).
+   */ async waitForAllNodes(predicate, opts = {}) {
+        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`. */ waitForAllNodesToReachProvenCheckpoint(target, opts = {}) {
+        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`. */ waitForAllNodesToReachCheckpoint(target, opts = {}) {
+        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.
+   */ waitForAllNodesToReachBlockAtSlot(slot, tag, match = (block)=>block.header.globalVariables.slotNumber === slot, opts = {}) {
+        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.
+   */ findSlotsWithProposers(count, predicate, opts = {}) {
+        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 !== 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]`).
+   */ watchNodeSequencerEvents(nodes, getMetadata = (i)=>({
+            validator: this.validators[i].attester
+        })) {
+        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.
+   */ waitForOffenseOnNodes(nodes, match, opts = {}) {
+        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/dest/multi-node/slashing/inactivity_setup.d.ts

@@ -0,0 +1,27 @@
+import type { AztecNodeService } from '@aztec/aztec-node';
+import type { EthAddress } from '@aztec/aztec.js/addresses';
+import { MultiNodeTestContext } from '../multi_node_test_context.js';
+/** Stateful fixture for the inactivity-slash suites: a slasher-enabled committee on the mock-gossip bus. */
+export declare class InactivityTest {
+    test: MultiNodeTestContext;
+    nodes: AztecNodeService[];
+    activeNodes: AztecNodeService[];
+    inactiveNodes: AztecNodeService[];
+    offlineValidators: EthAddress[];
+    private inactiveNodeCount;
+    constructor(opts: {
+        inactiveNodeCount: number;
+    });
+    static setup(opts: {
+        slashInactivityConsecutiveEpochThreshold: number;
+        inactiveNodeCount: number;
+    }): Promise<InactivityTest>;
+    private run;
+    teardown(): Promise<void>;
+    get rollup(): import("@aztec/ethereum/contracts").RollupContract;
+    get logger(): import("@aztec/foundation/log").Logger;
+    get config(): import("@aztec/aztec-node").AztecNodeConfig;
+    get monitor(): import("@aztec/ethereum/test").ChainMonitor;
+    get slashingAmount(): bigint;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5hY3Rpdml0eV9zZXR1cC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL211bHRpLW5vZGUvc2xhc2hpbmcvaW5hY3Rpdml0eV9zZXR1cC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQzFELE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBRzVELE9BQU8sRUFDTCxvQkFBb0IsRUFHckIsTUFBTSwrQkFBK0IsQ0FBQztBQWdCdkMsNEdBQTRHO0FBQzVHLHFCQUFhLGNBQWM7SUFDbEIsSUFBSSxFQUFHLG9CQUFvQixDQUFDO0lBQzVCLEtBQUssRUFBRyxnQkFBZ0IsRUFBRSxDQUFDO0lBQzNCLFdBQVcsRUFBRyxnQkFBZ0IsRUFBRSxDQUFDO0lBQ2pDLGFBQWEsRUFBRyxnQkFBZ0IsRUFBRSxDQUFDO0lBQ25DLGlCQUFpQixFQUFHLFVBQVUsRUFBRSxDQUFDO0lBRXhDLE9BQU8sQ0FBQyxpQkFBaUIsQ0FBUztJQUVsQyxZQUFZLElBQUksRUFBRTtRQUFFLGlCQUFpQixFQUFFLE1BQU0sQ0FBQTtLQUFFLEVBRTlDO0lBRUQsT0FBYSxLQUFLLENBQUMsSUFBSSxFQUFFO1FBQ3ZCLHdDQUF3QyxFQUFFLE1BQU0sQ0FBQztRQUNqRCxpQkFBaUIsRUFBRSxNQUFNLENBQUM7S0FDM0IsR0FBRyxPQUFPLENBQUMsY0FBYyxDQUFDLENBSTFCO1lBRWEsR0FBRztJQW9FSixRQUFRLGtCQUVwQjtJQUVELElBQVcsTUFBTSx1REFFaEI7SUFFRCxJQUFXLE1BQU0sMkNBRWhCO0lBRUQsSUFBVyxNQUFNLGdEQUVoQjtJQUVELElBQVcsT0FBTyxnREFFakI7SUFFRCxJQUFXLGNBQWMsV0FFeEI7Q0FDRiJ9

package/dest/multi-node/slashing/inactivity_setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inactivity_setup.d.ts","sourceRoot":"","sources":["../../../src/multi-node/slashing/inactivity_setup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAG5D,OAAO,EACL,oBAAoB,EAGrB,MAAM,+BAA+B,CAAC;AAgBvC,4GAA4G;AAC5G,qBAAa,cAAc;IAClB,IAAI,EAAG,oBAAoB,CAAC;IAC5B,KAAK,EAAG,gBAAgB,EAAE,CAAC;IAC3B,WAAW,EAAG,gBAAgB,EAAE,CAAC;IACjC,aAAa,EAAG,gBAAgB,EAAE,CAAC;IACnC,iBAAiB,EAAG,UAAU,EAAE,CAAC;IAExC,OAAO,CAAC,iBAAiB,CAAS;IAElC,YAAY,IAAI,EAAE;QAAE,iBAAiB,EAAE,MAAM,CAAA;KAAE,EAE9C;IAED,OAAa,KAAK,CAAC,IAAI,EAAE;QACvB,wCAAwC,EAAE,MAAM,CAAC;QACjD,iBAAiB,EAAE,MAAM,CAAC;KAC3B,GAAG,OAAO,CAAC,cAAc,CAAC,CAI1B;YAEa,GAAG;IAoEJ,QAAQ,kBAEpB;IAED,IAAW,MAAM,uDAEhB;IAED,IAAW,MAAM,2CAEhB;IAED,IAAW,MAAM,gDAEhB;IAED,IAAW,OAAO,gDAEjB;IAED,IAAW,cAAc,WAExB;CACF"}

package/dest/multi-node/slashing/inactivity_setup.js

@@ -0,0 +1,111 @@
+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 {
+    test;
+    nodes;
+    activeNodes;
+    inactiveNodes;
+    offlineValidators;
+    inactiveNodeCount;
+    constructor(opts){
+        this.inactiveNodeCount = opts.inactiveNodeCount;
+    }
+    static async setup(opts) {
+        const inactivityTest = new InactivityTest(opts);
+        await inactivityTest.run(opts);
+        return inactivityTest;
+    }
+    async run(opts) {
+        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,
+            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,
+            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));
+    }
+    async teardown() {
+        await this.test.teardown();
+    }
+    get rollup() {
+        return this.test.rollup;
+    }
+    get logger() {
+        return this.test.logger;
+    }
+    get config() {
+        return this.test.context.config;
+    }
+    get monitor() {
+        return this.test.monitor;
+    }
+    get slashingAmount() {
+        return SLASHING_AMOUNT;
+    }
+}

package/dest/multi-node/slashing/setup.d.ts

@@ -0,0 +1,167 @@
+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 { EthAddress } from '@aztec/foundation/eth-address';
+import { type OffenseType } from '@aztec/slasher';
+import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
+import type { TxHash } from '@aztec/stdlib/tx';
+import { jest } from '@jest/globals';
+import type { MultiNodeTestContext } from '../multi_node_test_context.js';
+export declare const NUM_VALIDATORS = 4;
+export declare const COMMITTEE_SIZE = 4;
+export declare const ETHEREUM_SLOT_DURATION = 8;
+export declare const AZTEC_SLOT_DURATION: number;
+export declare const BLOCK_DURATION = 4;
+export declare const slashingUnit: bigint;
+export declare const slashingQuorum = 3;
+export declare const slashingRoundSize = 4;
+export declare 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 declare const baseSlashingOpts: {
+    anvilSlotsInAnEpoch: number;
+    listenAddress: string;
+    aztecEpochDuration: number;
+    ethereumSlotDuration: number;
+    aztecSlotDuration: number;
+    aztecTargetCommitteeSize: number;
+    aztecProofSubmissionEpochs: number;
+    slashInactivityConsecutiveEpochThreshold: number;
+    minTxsPerBlock: number;
+    slashingQuorum: number;
+    slashingRoundSizeInEpochs: number;
+    slashAmountSmall: bigint;
+    slashAmountMedium: bigint;
+    slashAmountLarge: bigint;
+    blockDurationMs: number;
+    slashDuplicateProposalPenalty: bigint;
+    slashingOffsetInRounds: number;
+};
+/**
+ * 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 declare const SENTINEL_TIMING: {
+    readonly anvilSlotsInAnEpoch: 4;
+    readonly listenAddress: "127.0.0.1";
+    readonly ethereumSlotDuration: 4;
+    readonly aztecSlotDuration: 8;
+    readonly aztecEpochDuration: 2;
+    readonly sentinelEnabled: true;
+};
+/** 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 declare function findSlashOffense(offenses: SlashOffense[], validator: EthAddress, offenseType: OffenseType, slot: SlotNumber): SlashOffense | undefined;
+export declare function awaitProposalExecution(slashingProposer: SlashingProposerContract, timeoutSeconds: number, logger: Logger): Promise<bigint>;
+export declare function awaitCommitteeExists({ rollup, logger }: {
+    rollup: RollupContract;
+    logger: Logger;
+}): Promise<readonly `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 declare function findUpcomingProposerSlot({ epochCache, cheatCodes, targetProposer, logger, minLeadSlots, maxSlotsToScan }: {
+    epochCache: EpochCacheInterface;
+    cheatCodes: RollupCheatCodes;
+    targetProposer: EthAddress;
+    logger: Logger;
+    minLeadSlots: number;
+    maxSlotsToScan?: number;
+}): Promise<SlotNumber>;
+/**
+ * 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 declare function advanceToEpochBeforeProposer({ epochCache, cheatCodes, targetProposer, logger, maxAttempts, warmupSlots }: {
+    epochCache: EpochCacheInterface;
+    cheatCodes: RollupCheatCodes;
+    targetProposer: EthAddress;
+    logger: Logger;
+    maxAttempts?: number;
+    warmupSlots?: number;
+}): Promise<{
+    targetEpoch: EpochNumber;
+    targetSlot: SlotNumber;
+}>;
+export declare function awaitOffenseDetected({ logger, nodeAdmin, slashingRoundSize, epochDuration, waitUntilOffenseCount, timeoutSeconds }: {
+    nodeAdmin: AztecNodeAdmin;
+    logger: Logger;
+    slashingRoundSize: number;
+    epochDuration: number;
+    waitUntilOffenseCount?: number;
+    timeoutSeconds?: number;
+}): Promise<import("@aztec/slasher").Offense[]>;
+/**
+ * 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 declare 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;
+}): Promise<void>;
+/** Resolves the slot at which `node` includes `txHash`, by reading the tx receipt and block header. */
+export declare function getMinedSlot(node: AztecNodeService, txHash: {
+    toString(): string;
+}): Promise<number>;
+/**
+ * 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 declare function submitTxsThroughNode(test: MultiNodeTestContext, node: AztecNodeService, numTxs: number): Promise<TxHash[]>;
+export { jest };
+//# sourceMappingURL=data:application/json;base64,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