feat: Simplify slasher settings (#16625)

Fixes #16597

Builds on #16617

Author: spalladino

l1-contracts/src/core/RollupCore.sol

@@ -249,7 +249,7 @@ contract RollupCore is EIP712("Aztec Rollup", "1"), Ownable, IStakingCore, IVali
         _config.slashingRoundSize,
         _config.slashingLifetimeInRounds,
         _config.slashingExecutionDelayInRounds,
-        _config.slashingUnit,
+        _config.slashAmounts,
         _config.targetCommitteeSize,
         _config.aztecEpochDuration,
         _config.slashingOffsetInRounds

l1-contracts/src/core/interfaces/IRollup.sol

@@ -61,7 +61,7 @@ struct RollupConfigInput {
   uint256 slashingRoundSize;
   uint256 slashingLifetimeInRounds;
   uint256 slashingExecutionDelayInRounds;
-  uint256 slashingUnit;
+  uint256[3] slashAmounts;
   uint256 slashingOffsetInRounds;
   SlasherFlavor slasherFlavor;
   address slashingVetoer;

l1-contracts/src/core/libraries/Errors.sol

@@ -184,7 +184,7 @@ library Errors {
   error TallySlashingProposer__InvalidCommitteeCommitment();
   error TallySlashingProposer__InvalidQuorumAndRoundSize(uint256 quorum, uint256 roundSize);
   error TallySlashingProposer__QuorumMustBeGreaterThanZero();
-  error TallySlashingProposer__SlashingUnitMustBeGreaterThanZero(uint256 slashingUnit);
+  error TallySlashingProposer__InvalidSlashAmounts(uint256[3] slashAmounts);
   error TallySlashingProposer__LifetimeMustBeGreaterThanExecutionDelay(uint256 lifetime, uint256 executionDelay);
   error TallySlashingProposer__LifetimeMustBeLessThanRoundabout(uint256 lifetime, uint256 roundabout);
   error TallySlashingProposer__RoundSizeInEpochsMustBeGreaterThanZero(uint256 roundSizeInEpochs);

l1-contracts/src/core/libraries/rollup/TallySlasherDeploymentExtLib.sol

@@ -24,7 +24,7 @@ library TallySlasherDeploymentExtLib {
     uint256 _roundSize,
     uint256 _lifetimeInRounds,
     uint256 _executionDelayInRounds,
-    uint256 _slashingUnit,
+    uint256[3] calldata _slashAmounts,
     uint256 _committeeSize,
     uint256 _epochDuration,
     uint256 _slashOffsetInRounds
@@ -40,7 +40,7 @@ library TallySlasherDeploymentExtLib {
       _roundSize,
       _lifetimeInRounds,
       _executionDelayInRounds,
-      _slashingUnit,
+      _slashAmounts,
       _committeeSize,
       _epochDuration,
       _slashOffsetInRounds

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

@@ -80,7 +80,7 @@ import {SafeCast} from "@oz/utils/math/SafeCast.sol";
  *      - EXECUTION_DELAY_IN_ROUNDS: Rounds to wait before allowing execution
  *      - LIFETIME_IN_ROUNDS: Maximum age of rounds that can still be executed
  *      - SLASH_OFFSET_IN_ROUNDS: How far back to look for validators to slash
- *      - SLASHING_UNIT: Base amount of slashing per unit voted
+ *      - SLASH_AMOUNT_SMALL/MEDIUM/LARGE: Specific amounts for each slash unit level
  *      - COMMITTEE_SIZE: Number of validators per committee
  */
 contract TallySlashingProposer is EIP712 {
@@ -195,8 +195,19 @@ contract TallySlashingProposer is EIP712 {
   /**
    * @notice Base amount of stake to slash per slashing unit (in wei)
    * @dev Validators can be voted to be slashed by 1-3 units, multiplied by this base amount
+   * @notice Small slash amount for 1 unit votes (in wei)
    */
-  uint256 public immutable SLASHING_UNIT;
+  uint256 public immutable SLASH_AMOUNT_SMALL;
+
+  /**
+   * @notice Medium slash amount for 2 unit votes (in wei)
+   */
+  uint256 public immutable SLASH_AMOUNT_MEDIUM;
+
+  /**
+   * @notice Large slash amount for 3 unit votes (in wei)
+   */
+  uint256 public immutable SLASH_AMOUNT_LARGE;
 
   /**
    * @notice Minimum number of votes required to slash a validator
@@ -275,7 +286,7 @@ contract TallySlashingProposer is EIP712 {
    * _executionDelayInRounds and < ROUNDABOUT_SIZE)
    * @param _executionDelayInRounds The number of rounds to wait after a round ends before it can be executed (provides
    * time for review)
-   * @param _slashingUnit The base amount of stake to slash per slashing unit (must be > 0)
+   * @param _slashAmounts Array of 3 slash amounts [small, medium, large] for 1, 2, 3 unit votes (all must be > 0)
    * @param _committeeSize The number of validators in each committee (must be > 0)
    * @param _epochDuration The number of slots in each epoch (used to calculate ROUND_SIZE_IN_EPOCHS)
    * @param _slashOffsetInRounds How many rounds in the past to look when determining which validators to slash (must be
@@ -288,14 +299,16 @@ contract TallySlashingProposer is EIP712 {
     uint256 _roundSize,
     uint256 _lifetimeInRounds,
     uint256 _executionDelayInRounds,
-    uint256 _slashingUnit,
+    uint256[3] memory _slashAmounts,
     uint256 _committeeSize,
     uint256 _epochDuration,
     uint256 _slashOffsetInRounds
   ) EIP712("TallySlashingProposer", "1") {
     INSTANCE = _instance;
     SLASHER = _slasher;
-    SLASHING_UNIT = _slashingUnit;
+    SLASH_AMOUNT_SMALL = _slashAmounts[0];
+    SLASH_AMOUNT_MEDIUM = _slashAmounts[1];
+    SLASH_AMOUNT_LARGE = _slashAmounts[2];
     QUORUM = _quorum;
     ROUND_SIZE = _roundSize;
     ROUND_SIZE_IN_EPOCHS = _roundSize / _epochDuration;
@@ -318,7 +331,8 @@ contract TallySlashingProposer is EIP712 {
     require(ROUND_SIZE > 1, Errors.TallySlashingProposer__InvalidQuorumAndRoundSize(QUORUM, ROUND_SIZE));
     require(QUORUM > ROUND_SIZE / 2, Errors.TallySlashingProposer__InvalidQuorumAndRoundSize(QUORUM, ROUND_SIZE));
     require(QUORUM <= ROUND_SIZE, Errors.TallySlashingProposer__InvalidQuorumAndRoundSize(QUORUM, ROUND_SIZE));
-    require(SLASHING_UNIT > 0, Errors.TallySlashingProposer__SlashingUnitMustBeGreaterThanZero(SLASHING_UNIT));
+    require(_slashAmounts[0] <= _slashAmounts[1], Errors.TallySlashingProposer__InvalidSlashAmounts(_slashAmounts));
+    require(_slashAmounts[1] <= _slashAmounts[2], Errors.TallySlashingProposer__InvalidSlashAmounts(_slashAmounts));
     require(
       LIFETIME_IN_ROUNDS > EXECUTION_DELAY_IN_ROUNDS,
       Errors.TallySlashingProposer__LifetimeMustBeGreaterThanExecutionDelay(
@@ -863,11 +877,19 @@ contract TallySlashingProposer is EIP712 {
 
           // Check if this slash amount has reached quorum
           if (voteCountForValidator >= QUORUM) {
+            // Convert units to actual slash amount
+            uint256 slashAmount;
+            if (j == 1) {
+              slashAmount = SLASH_AMOUNT_SMALL;
+            } else if (j == 2) {
+              slashAmount = SLASH_AMOUNT_MEDIUM;
+            } else if (j == 3) {
+              slashAmount = SLASH_AMOUNT_LARGE;
+            }
+
             // Record the slashing action
-            actions[actionCount] = SlashAction({
-              validator: _committees[i / COMMITTEE_SIZE][i % COMMITTEE_SIZE],
-              slashAmount: SLASHING_UNIT * j
-            });
+            actions[actionCount] =
+              SlashAction({validator: _committees[i / COMMITTEE_SIZE][i % COMMITTEE_SIZE], slashAmount: slashAmount});
             ++actionCount;
 
             // Mark this committee as having at least one slashed validator

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

@@ -187,7 +187,8 @@ contract BenchmarkRollupTest is FeeModelTestPoints, DecoderBase {
       uint256 tallyRoundSize = EPOCH_DURATION * 2; // 64; // 2 * EPOCH_DURATION (32) = 64
       uint256 tallyQuorum = tallyRoundSize / 2 + 1; // Must be > ROUND_SIZE / 2
       builder.setSlasherFlavor(SlasherFlavor.TALLY).setSlashingQuorum(tallyQuorum).setSlashingRoundSize(tallyRoundSize)
-        .setSlashingLifetimeInRounds(5).setSlashingExecutionDelayInRounds(1).setSlashingUnit(1e18);
+        .setSlashingLifetimeInRounds(5).setSlashingExecutionDelayInRounds(1).setSlashAmountSmall(1e18)
+        .setSlashAmountMedium(2e18).setSlashAmountLarge(3e18);
     }
 
     builder.deploy();

l1-contracts/test/builder/RollupBuilder.sol

@@ -205,8 +205,18 @@ contract RollupBuilder is Test {
     return this;
   }
 
-  function setSlashingUnit(uint256 _slashingUnit) public returns (RollupBuilder) {
-    config.rollupConfigInput.slashingUnit = _slashingUnit;
+  function setSlashAmountSmall(uint256 _slashAmountSmall) public returns (RollupBuilder) {
+    config.rollupConfigInput.slashAmounts[0] = _slashAmountSmall;
+    return this;
+  }
+
+  function setSlashAmountMedium(uint256 _slashAmountMedium) public returns (RollupBuilder) {
+    config.rollupConfigInput.slashAmounts[1] = _slashAmountMedium;
+    return this;
+  }
+
+  function setSlashAmountLarge(uint256 _slashAmountLarge) public returns (RollupBuilder) {
+    config.rollupConfigInput.slashAmounts[2] = _slashAmountLarge;
     return this;
   }
 

l1-contracts/test/governance/scenario/slashing/TallySlashing.t.sol

@@ -91,9 +91,14 @@ contract SlashingTest is TestBase {
     // Create votes - for tally slashing we need to encode votes as bytes
     // Each validator gets a slash amount between 1-3 units
     // For simplicity, we'll vote to slash all validators by the same amount
-    uint256 slashUnits = _slashAmount / slashingProposer.SLASHING_UNIT();
-    if (slashUnits == 0) slashUnits = 1; // Minimum 1 unit
-    if (slashUnits > 3) slashUnits = 3; // Maximum 3 units
+    uint256 slashUnits;
+    if (_slashAmount >= slashingProposer.SLASH_AMOUNT_LARGE()) {
+      slashUnits = 3;
+    } else if (_slashAmount >= slashingProposer.SLASH_AMOUNT_MEDIUM()) {
+      slashUnits = 2;
+    } else {
+      slashUnits = 1;
+    }
 
     // Calculate expected vote length: (COMMITTEE_SIZE * ROUND_SIZE_IN_EPOCHS) / 4
     uint256 totalValidators = slashingProposer.COMMITTEE_SIZE() * slashingProposer.ROUND_SIZE_IN_EPOCHS();
@@ -335,10 +340,18 @@ contract SlashingTest is TestBase {
     slashingProposer.executeRound(firstSlashingRound, committees);
 
     // Calculate actual slash amount (limited by max 3 units)
-    uint256 slashUnits = slashAmount1 / slashingProposer.SLASHING_UNIT();
-    if (slashUnits == 0) slashUnits = 1; // Minimum 1 unit
-    if (slashUnits > 3) slashUnits = 3; // Maximum 3 units
-    uint256 actualSlashAmount = slashUnits * slashingProposer.SLASHING_UNIT();
+    uint256 slashUnits;
+    uint256 actualSlashAmount;
+    if (slashAmount1 >= slashingProposer.SLASH_AMOUNT_LARGE()) {
+      slashUnits = 3;
+      actualSlashAmount = slashingProposer.SLASH_AMOUNT_LARGE();
+    } else if (slashAmount1 >= slashingProposer.SLASH_AMOUNT_MEDIUM()) {
+      slashUnits = 2;
+      actualSlashAmount = slashingProposer.SLASH_AMOUNT_MEDIUM();
+    } else {
+      slashUnits = 1;
+      actualSlashAmount = slashingProposer.SLASH_AMOUNT_SMALL();
+    }
 
     // Check balances
     for (uint256 i = 0; i < howManyToSlash; i++) {

l1-contracts/test/harnesses/TestConstants.sol

@@ -25,7 +25,9 @@ library TestConstants {
   uint256 internal constant AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS = 0;
   uint256 internal constant AZTEC_SLASHING_OFFSET_IN_ROUNDS = 2;
   address internal constant AZTEC_SLASHING_VETOER = address(0);
-  uint256 internal constant AZTEC_SLASHING_UNIT = 20e18;
+  uint256 internal constant AZTEC_SLASH_AMOUNT_SMALL = 20e18;
+  uint256 internal constant AZTEC_SLASH_AMOUNT_MEDIUM = 40e18;
+  uint256 internal constant AZTEC_SLASH_AMOUNT_LARGE = 60e18;
   uint256 internal constant AZTEC_MANA_TARGET = 100_000_000;
   uint256 internal constant AZTEC_ENTRY_QUEUE_FLUSH_SIZE_MIN = 4;
   uint256 internal constant AZTEC_ENTRY_QUEUE_FLUSH_SIZE_QUOTIENT = 2;
@@ -106,7 +108,7 @@ library TestConstants {
       rewardConfig: getRewardConfig(),
       rewardBoostConfig: getRewardBoostConfig(),
       stakingQueueConfig: getStakingQueueConfig(),
-      slashingUnit: AZTEC_SLASHING_UNIT,
+      slashAmounts: [AZTEC_SLASH_AMOUNT_SMALL, AZTEC_SLASH_AMOUNT_MEDIUM, AZTEC_SLASH_AMOUNT_LARGE],
       slasherFlavor: SlasherFlavor.EMPIRE
     });
 

l1-contracts/test/slashing/TallySlashingProposer.t.sol

@@ -86,9 +86,11 @@ contract TallySlashingProposerTest is TestBase {
     RollupBuilder builder = new RollupBuilder(address(this)).setValidators(initialValidators).setTargetCommitteeSize(
       COMMITTEE_SIZE
     ).setSlashingQuorum(QUORUM).setSlashingRoundSize(ROUND_SIZE).setSlashingLifetimeInRounds(LIFETIME_IN_ROUNDS)
-      .setSlashingExecutionDelayInRounds(EXECUTION_DELAY_IN_ROUNDS).setEpochDuration(EPOCH_DURATION).setSlashingUnit(
+      .setSlashingExecutionDelayInRounds(EXECUTION_DELAY_IN_ROUNDS).setEpochDuration(EPOCH_DURATION).setSlashAmountSmall(
       SLASHING_UNIT
-    ).setSlasherFlavor(SlasherFlavor.TALLY);
+    ).setSlashAmountMedium(SLASHING_UNIT * 2).setSlashAmountLarge(SLASHING_UNIT * 3).setSlasherFlavor(
+      SlasherFlavor.TALLY
+    );
     builder.deploy();
 
     rollup = builder.getConfig().rollup;