feat: Change default slasher from empire to tally

Updates default slasher used from empire to tally. Fixes tests as needed.

Other changes include:
- Changing default slashing round size from 200 to 192, since rounds must be multiple of epochs
- Removing `slashProposerRoundPollingIntervalSeconds`, since this now happens every 200ms as it does not need querying the chain
- Override gas limit when deploying rollup to 15M
- Change Rollup contract to **not** deploy a slasher (and proposer) if target committee size is zero
- Fix vote encoding helper bug
- Split inactivity slash e2e test out of the validator sentinel test

Changes coming up on future PRs:
- Improve config variables (see #16597) and add more validations
- Add force-slash-list and do-not-slash of validators (defaulting to self) for slashing
- Clean up old offenses from store
- Check if a slash is vetoed before trying to execute and skip it if so
- Add a mapping from slash-units to slash amounts (instead of just multiplying)
- Reduce gas cost of slashing!

Co-authored-by: Santiago Palladino <[email protected]>

Author: AztecBot

l1-contracts/src/core/RollupCore.sol

@@ -237,7 +237,10 @@ contract RollupCore is EIP712("Aztec Rollup", "1"), Ownable, IStakingCore, IVali
 
     // We call one external library or another based on the slasher flavor
     // This allows us to keep the slash flavors in separate external libraries so we do not exceed max contract size
-    if (_config.slasherFlavor == SlasherFlavor.TALLY) {
+    // Note that we do not deploy a slasher if we run with no committees (i.e. targetCommitteeSize == 0)
+    if (_config.targetCommitteeSize == 0) {
+      slasher = ISlasher(address(0));
+    } else if (_config.slasherFlavor == SlasherFlavor.TALLY) {
       slasher = TallySlasherDeploymentExtLib.deployTallySlasher(
         address(this),
         _config.slashingVetoer,

l1-contracts/src/core/slashing/TallySlashingProposer.sol

@@ -144,7 +144,7 @@ contract TallySlashingProposer is EIP712 {
    * @notice EIP-712 type hash for the Vote struct used in signature verification
    * @dev Defines the structure: Vote(uint256 slot,bytes votes) for EIP-712 signing
    */
-  bytes32 public constant VOTE_TYPEHASH = keccak256("Vote(uint256 slot,bytes votes)");
+  bytes32 public constant VOTE_TYPEHASH = keccak256("Vote(bytes votes,uint256 slot)");
 
   /**
    * @notice Type of slashing proposer (either Tally or Empire)

l1-contracts/test/benchmark/happy.t.sol

@@ -135,6 +135,7 @@ contract BenchmarkRollupTest is FeeModelTestPoints, DecoderBase {
   bool internal IS_IGNITION;
 
   Rollup internal rollup;
+  Slasher internal slasher;
 
   address internal coinbase = address(bytes20("MONEY MAKER"));
   TestERC20 internal asset;
@@ -193,7 +194,8 @@ contract BenchmarkRollupTest is FeeModelTestPoints, DecoderBase {
 
     asset = builder.getConfig().testERC20;
     rollup = builder.getConfig().rollup;
-    slashingProposer = Slasher(rollup.getSlasher()).PROPOSER();
+    slasher = Slasher(rollup.getSlasher());
+    slashingProposer = address(slasher) == address(0) ? address(0) : slasher.PROPOSER();
 
     SlashFactory slashFactory = new SlashFactory(IValidatorSelection(address(rollup)));
     address[] memory toSlash = new address[](0);

yarn-project/aztec-node/src/sentinel/sentinel.test.ts

@@ -463,60 +463,6 @@ describe('sentinel', () => {
         },
       ] satisfies WantToSlashArgs[]);
     });
-
-    it('should agree with slash', async () => {
-      const performance = Object.fromEntries(
-        Array.from({ length: 10 }, (_, i) => [
-          `0x000000000000000000000000000000000000000${i}`,
-          {
-            missed: i * 10,
-            total: 100,
-          },
-        ]),
-      );
-
-      await sentinel.updateProvenPerformance(1n, performance);
-      const emitSpy = jest.spyOn(sentinel, 'emit');
-
-      sentinel.handleProvenPerformance(1n, performance);
-      const penalty = config.slashInactivityCreatePenalty;
-
-      expect(emitSpy).toHaveBeenCalledWith(WANT_TO_SLASH_EVENT, [
-        {
-          validator: EthAddress.fromString(`0x0000000000000000000000000000000000000008`),
-          amount: penalty,
-          offenseType: OffenseType.INACTIVITY,
-          epochOrSlot: 1n,
-        },
-        {
-          validator: EthAddress.fromString(`0x0000000000000000000000000000000000000009`),
-          amount: penalty,
-          offenseType: OffenseType.INACTIVITY,
-          epochOrSlot: 1n,
-        },
-      ] satisfies WantToSlashArgs[]);
-
-      for (let i = 0; i < 10; i++) {
-        const expectedAgree = i >= 6;
-        const actualAgree = await sentinel.shouldSlash({
-          validator: EthAddress.fromString(`0x000000000000000000000000000000000000000${i}`),
-          amount: config.slashInactivityMaxPenalty,
-          offenseType: OffenseType.INACTIVITY,
-          epochOrSlot: 1n,
-        });
-        expect(actualAgree).toBe(expectedAgree);
-
-        // We never slash if the penalty is above the max penalty
-        await expect(
-          sentinel.shouldSlash({
-            validator: EthAddress.fromString(`0x000000000000000000000000000000000000000${i}`),
-            amount: config.slashInactivityMaxPenalty + 1n,
-            offenseType: OffenseType.INACTIVITY,
-            epochOrSlot: 1n,
-          }),
-        ).resolves.toBe(false);
-      }
-    });
   });
 });
 

yarn-project/aztec-node/src/sentinel/sentinel.ts

@@ -5,8 +5,7 @@ import { createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 import { L2TipsMemoryStore, type L2TipsStore } from '@aztec/kv-store/stores';
 import type { P2PClient } from '@aztec/p2p';
-import { OffenseType } from '@aztec/slasher';
-import { WANT_TO_SLASH_EVENT, type WantToSlashArgs, type Watcher, type WatcherEmitter } from '@aztec/slasher';
+import { OffenseType, WANT_TO_SLASH_EVENT, type Watcher, type WatcherEmitter } from '@aztec/slasher';
 import type { SlasherConfig } from '@aztec/slasher/config';
 import {
   type L2BlockSource,
@@ -121,9 +120,9 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
     }
 
     const epoch = getEpochAtSlot(block.header.getSlot(), await this.archiver.getL1Constants());
-    this.logger.info(`Computing proven performance for epoch ${epoch}`);
+    this.logger.debug(`Computing proven performance for epoch ${epoch}`);
     const performance = await this.computeProvenPerformance(epoch);
-    this.logger.info(`Proven performance for epoch ${epoch}`, performance);
+    this.logger.info(`Computed proven performance for epoch ${epoch}`, performance);
 
     await this.updateProvenPerformance(epoch, performance);
     this.handleProvenPerformance(epoch, performance);
@@ -183,38 +182,12 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
       epochOrSlot: epoch,
     }));
 
-    this.logger.info(`Criminals: ${criminals.length}`, { args });
-
     if (criminals.length > 0) {
+      this.logger.info(`Identified ${criminals.length} validators to slash due to inactivity`, { args });
       this.emit(WANT_TO_SLASH_EVENT, args);
     }
   }
 
-  public async shouldSlash({ validator, amount }: WantToSlashArgs): Promise<boolean> {
-    const l1Constants = this.epochCache.getL1Constants();
-    const ttlL2Slots = this.config.slashPayloadTtlSeconds / l1Constants.slotDuration;
-    const ttlEpochs = BigInt(Math.ceil(ttlL2Slots / l1Constants.epochDuration));
-
-    const currentEpoch = this.epochCache.getEpochAndSlotNow().epoch;
-    const performance = await this.store.getProvenPerformance(validator);
-    const isCriminal =
-      performance
-        .filter(p => p.epoch >= currentEpoch - ttlEpochs)
-        .findIndex(p => p.missed / p.total >= this.config.slashInactivitySignalTargetPercentage) !== -1;
-    if (isCriminal) {
-      if (amount <= this.config.slashInactivityMaxPenalty) {
-        return true;
-      } else {
-        this.logger.warn(`Validator ${validator} is a criminal but the penalty is too high`, {
-          amount,
-          maxPenalty: this.config.slashInactivityMaxPenalty,
-        });
-        return false;
-      }
-    }
-    return false;
-  }
-
   /**
    * Process data for two L2 slots ago.
    * Note that we do not process historical data, since we rely on p2p data for processing,

yarn-project/aztec/src/cli/chain_l2_config.ts

@@ -183,10 +183,10 @@ export const alphaTestnetL2ChainConfig: L2ChainConfig = {
   activationThreshold: DefaultL1ContractsConfig.activationThreshold,
   /** The minimum stake for a validator. */
   ejectionThreshold: DefaultL1ContractsConfig.ejectionThreshold,
-  /** The slashing quorum */
-  slashingQuorum: 101,
   /** The slashing round size */
-  slashingRoundSize: 200,
+  slashingRoundSize: 32 * 6, // 6 epochs
+  /** The slashing quorum */
+  slashingQuorum: (32 * 6) / 2 + 1, // 6 epochs, majority of validators
   /** Governance proposing quorum */
   governanceProposerQuorum: 151,
   /** Governance proposing round size */

yarn-project/end-to-end/src/e2e_p2p/data_withholding_slash.test.ts

@@ -8,7 +8,7 @@ import path from 'path';
 import { shouldCollectMetrics } from '../fixtures/fixtures.js';
 import { createNodes } from '../fixtures/setup_p2p_test.js';
 import { P2PNetworkTest } from './p2p_network.js';
-import { awaitCommitteeExists, awaitCommitteeKicked } from './shared.js';
+import { awaitCommitteeExists, awaitCommitteeKicked, awaitOffenseDetected } from './shared.js';
 
 jest.setTimeout(1000000);
 
@@ -37,6 +37,7 @@ describe('e2e_p2p_data_withholding_slash', () => {
   let t: P2PNetworkTest;
   let nodes: AztecNodeService[];
 
+  const slashingUnit = BigInt(20e18);
   const slashingQuorum = 3;
   const slashingRoundSize = 4;
   // This test needs longer slot window to ensure that the client has enough time to submit their txs,
@@ -58,6 +59,7 @@ describe('e2e_p2p_data_withholding_slash', () => {
         aztecProofSubmissionEpochs: 0, // effectively forces instant reorgs
         slashingQuorum,
         slashingRoundSize,
+        slashingUnit,
         minTxsPerBlock: 0,
       },
     });
@@ -86,14 +88,18 @@ describe('e2e_p2p_data_withholding_slash', () => {
     const { rollup, slashingProposer, slashFactory } = await t.getContracts();
 
     // Jump forward to an epoch in the future such that the validator set is not empty
-    {
-      const newTime = await t.ctx.cheatCodes.rollup.advanceToEpoch(4n);
-      t.ctx.dateProvider.setTime(Number(newTime * 1000n));
-      // Send tx
-      await debugRollup();
-    }
+    await t.ctx.cheatCodes.rollup.advanceToEpoch(4n, { updateDateProvider: t.ctx.dateProvider });
+    await debugRollup();
+
+    const [activationThreshold, ejectionThreshold] = await Promise.all([
+      rollup.getActivationThreshold(),
+      rollup.getEjectionThreshold(),
+    ]);
+
+    // Slashing amount should be enough to kick validators out
+    const slashingAmount = slashingUnit * 3n;
+    expect(activationThreshold - slashingAmount).toBeLessThan(ejectionThreshold);
 
-    const slashingAmount = (await rollup.getActivationThreshold()) - (await rollup.getEjectionThreshold()) + 1n;
     t.ctx.aztecNodeConfig.slashPruneEnabled = true;
     t.ctx.aztecNodeConfig.slashPrunePenalty = slashingAmount;
     t.ctx.aztecNodeConfig.slashPruneMaxPenalty = slashingAmount;
@@ -123,13 +129,9 @@ describe('e2e_p2p_data_withholding_slash', () => {
     // Considering the slot duration is 32 seconds,
     // Considering the epoch duration is 2 slots,
     // we have ~64 seconds to do this.
-    {
-      const newTime = await t.ctx.cheatCodes.rollup.advanceToEpoch(8n);
-      t.ctx.dateProvider.setTime(Number(newTime * 1000n));
-      // Send L1 tx
-      await t.sendDummyTx();
-      await debugRollup();
-    }
+    await t.ctx.cheatCodes.rollup.advanceToEpoch(8n, { updateDateProvider: t.ctx.dateProvider });
+    await t.sendDummyTx();
+    await debugRollup();
 
     // Send Aztec txs
     t.logger.info('Setup account');
@@ -145,8 +147,7 @@ describe('e2e_p2p_data_withholding_slash', () => {
     }
 
     // Re-create the nodes.
-    // ASSUMING they sync in the middle of the epoch, they will "see" the reorg,
-    // and try to slash.
+    // ASSUMING they sync in the middle of the epoch, they will "see" the reorg, and try to slash.
     t.logger.info('Re-creating nodes');
     nodes = await createNodes(
       t.ctx.aztecNodeConfig,
@@ -158,6 +159,13 @@ describe('e2e_p2p_data_withholding_slash', () => {
       DATA_DIR,
     );
 
+    await awaitOffenseDetected({
+      epochDuration: t.ctx.aztecNodeConfig.aztecEpochDuration,
+      logger: t.logger,
+      nodeAdmin: nodes[0],
+      slashingRoundSize,
+    });
+
     await awaitCommitteeKicked({
       rollup,
       cheatCodes: t.ctx.cheatCodes.rollup,
@@ -167,7 +175,7 @@ describe('e2e_p2p_data_withholding_slash', () => {
       slashingRoundSize,
       aztecSlotDuration,
       logger: t.logger,
-      sendDummyTx: () => t.sendDummyTx().then(() => undefined),
+      dateProvider: t.ctx.dateProvider,
     });
   });
 });

yarn-project/end-to-end/src/e2e_p2p/inactivity_slash.test.ts

@@ -0,0 +1,112 @@
+import type { AztecNodeService } from '@aztec/aztec-node';
+import { EthAddress } from '@aztec/aztec.js';
+import { RollupContract } from '@aztec/ethereum';
+import { promiseWithResolvers } from '@aztec/foundation/promise';
+
+import { jest } from '@jest/globals';
+import fs from 'fs';
+import 'jest-extended';
+import os from 'os';
+import path from 'path';
+
+import { createNodes } from '../fixtures/setup_p2p_test.js';
+import { P2PNetworkTest } from './p2p_network.js';
+
+const NUM_NODES = 5;
+const NUM_VALIDATORS = NUM_NODES + 1; // We create an extra validator, who will not have a running node
+const BOOT_NODE_UDP_PORT = 4500;
+const EPOCH_DURATION = 2;
+const SLASHING_QUORUM = 3;
+const SLASHING_ROUND_SIZE = 4;
+const ETHEREUM_SLOT_DURATION = 4;
+const AZTEC_SLOT_DURATION = 8;
+const SLASHING_UNIT = BigInt(20e18);
+const SLASHING_AMOUNT = SLASHING_UNIT * 3n;
+
+const DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'inactivity-slash-'));
+
+jest.setTimeout(1000 * 60 * 10);
+
+describe('e2e_p2p_inactivity_slash', () => {
+  let t: P2PNetworkTest;
+  let nodes: AztecNodeService[];
+  let rollup: RollupContract;
+  let offlineValidator: EthAddress;
+
+  beforeAll(async () => {
+    t = await P2PNetworkTest.create({
+      testName: 'e2e_p2p_inactivity_slash',
+      numberOfNodes: 0,
+      numberOfValidators: NUM_VALIDATORS,
+      basePort: BOOT_NODE_UDP_PORT,
+      startProverNode: true,
+      initialConfig: {
+        aztecTargetCommitteeSize: NUM_NODES, // ensure we can progress even after slash happens
+        aztecSlotDuration: AZTEC_SLOT_DURATION,
+        ethereumSlotDuration: ETHEREUM_SLOT_DURATION,
+        aztecProofSubmissionEpochs: 1024, // effectively do not reorg
+        listenAddress: '127.0.0.1',
+        minTxsPerBlock: 0,
+        aztecEpochDuration: EPOCH_DURATION,
+        validatorReexecute: false,
+        sentinelEnabled: true,
+        slashingQuorum: SLASHING_QUORUM,
+        slashingRoundSize: SLASHING_ROUND_SIZE,
+        slashInactivityCreateTargetPercentage: 0.5,
+        slashInactivitySignalTargetPercentage: 0.1,
+        slashingUnit: SLASHING_UNIT,
+      },
+    });
+
+    await t.applyBaseSnapshots();
+    await t.setup();
+
+    // Set slashing penalties for inactivity
+    ({ rollup } = await t.getContracts());
+    const [activationThreshold, ejectionThreshold] = await Promise.all([
+      rollup.getActivationThreshold(),
+      rollup.getEjectionThreshold(),
+    ]);
+    expect(activationThreshold - SLASHING_AMOUNT).toBeLessThan(ejectionThreshold);
+    t.ctx.aztecNodeConfig.slashInactivityEnabled = true;
+    t.ctx.aztecNodeConfig.slashInactivityCreatePenalty = SLASHING_AMOUNT;
+    t.ctx.aztecNodeConfig.slashInactivityMaxPenalty = SLASHING_AMOUNT;
+
+    nodes = await createNodes(
+      t.ctx.aztecNodeConfig,
+      t.ctx.dateProvider,
+      t.bootstrapNodeEnr,
+      NUM_NODES, // Note we do not create the last validator yet, so it shows as offline
+      BOOT_NODE_UDP_PORT,
+      t.prefilledPublicData,
+
+      DATA_DIR,
+    );
+    await t.removeInitialNode();
+
+    offlineValidator = t.validators.at(-1)!.attester;
+    t.logger.warn(`Setup complete. Offline validator is ${offlineValidator}.`, {
+      validators: t.validators,
+      offlineValidator,
+    });
+  });
+
+  afterAll(async () => {
+    await t.stopNodes(nodes);
+    await t.teardown();
+    for (let i = 0; i < NUM_NODES; i++) {
+      fs.rmSync(`${DATA_DIR}-${i}`, { recursive: true, force: true, maxRetries: 3 });
+    }
+  });
+
+  it('slashes inactive validator', async () => {
+    const slashPromise = promiseWithResolvers<bigint>();
+    rollup.listenToSlash(args => {
+      t.logger.warn(`Slashed ${args.attester.toString()}`);
+      expect(offlineValidator.toString()).toEqual(args.attester.toString());
+      expect(args.amount).toEqual(SLASHING_AMOUNT);
+      slashPromise.resolve(args.amount);
+    });
+    await slashPromise.promise;
+  });
+});