chore: Reduce gas cost for tally slash proposer (#16617)

Reduce gas cost for executing a slash in the tally slash proposer.
Builds on
[16514](#16514).

## L1 changes

- Votes are represented with fixed-size arrays, so we save a storage
operation by not having to store or load the array length.
- Slash payloads are implemented using EIP1167 clones to reduce
deployment cost.
- Tally matrix is compacted to reduce memory usage, and votes are
processed in batches with early exits (since most vote arrays will be
sparse).
- Add a config option to deploy no slasher.
- Generic improvements like unchecked operations, loop unrolling, using
calldata over memory, etc.

## Other changes

- Add extra checks during deployment to alert if a tx reverted.
- Default tests to deploy no slasher (required to avoid triggering new
validations in the tally slashing proposer contract that failed when
epoch lengths were set to very small values).

## Gas benchmarks

Given the following settings:

```
  uint256 constant VALIDATOR_COUNT = 128;
  uint256 constant COMMITTEE_SIZE = 48;
  uint256 constant ROUND_SIZE_IN_EPOCHS = 6;
  uint256 constant EPOCH_DURATION = 32;
```

Gas costs before and after this change:

| How many slashed | Before | After | Reduction |
| -------- | -------- | -------- | -- |
| 1  | 4003168  | 1461217  | 63% |
| 48  | 12299046  | 8362076  | 32%  |

Author: spalladino

l1-contracts/src/core/RollupCore.sol

@@ -238,7 +238,7 @@ 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
     // Note that we do not deploy a slasher if we run with no committees (i.e. targetCommitteeSize == 0)
-    if (_config.targetCommitteeSize == 0) {
+    if (_config.targetCommitteeSize == 0 || _config.slasherFlavor == SlasherFlavor.NONE) {
       slasher = ISlasher(address(0));
     } else if (_config.slasherFlavor == SlasherFlavor.TALLY) {
       slasher = TallySlasherDeploymentExtLib.deployTallySlasher(

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

@@ -5,8 +5,9 @@ pragma solidity >=0.8.27;
 import {IPayload} from "@aztec/governance/interfaces/IPayload.sol";
 
 enum SlasherFlavor {
-  EMPIRE,
-  TALLY
+  NONE,
+  TALLY,
+  EMPIRE
 }
 
 interface ISlasher {

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

@@ -197,4 +197,8 @@ library Errors {
   error TallySlashingProposer__VotingNotOpen(SlashRound currentRound);
   error TallySlashingProposer__SlashOffsetMustBeGreaterThanZero(uint256 slashOffset);
   error TallySlashingProposer__InvalidEpochIndex(uint256 epochIndex, uint256 roundSizeInEpochs);
+  error TallySlashingProposer__VoteSizeTooBig(uint256 voteSize, uint256 maxSize);
+
+  // SlashPayloadLib
+  error SlashPayload_ArraySizeMismatch(uint256 expected, uint256 actual);
 }

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

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2024 Aztec Labs.
+pragma solidity >=0.8.27;
+
+import {Errors} from "./Errors.sol";
+
+/**
+ * @title SlashPayloadLib
+ * @author Aztec Labs
+ * @notice Library for encoding immutable arguments for SlashPayloadCloneable contracts
+ * @dev Provides utilities for encoding validator addresses and amounts into a format
+ *      suitable for use with EIP-1167 minimal proxy clones with immutable arguments
+ */
+library SlashPayloadLib {
+  /**
+   * @notice Encode immutable arguments for SlashPayloadCloneable clones
+   * @dev Encodes data in the format expected by SlashPayloadCloneable._getImmutableArgs()
+   *      Layout: [validatorSelection(20 bytes)][arrayLength(32 bytes)][validators+amounts array data]
+   *      Each validator entry: [address(20 bytes)][amount(12 bytes for uint96)]
+   * @param _validatorSelection Address of the validator selection contract
+   * @param _validators Array of validator addresses to slash
+   * @param _amounts Array of amounts to slash for each validator (uint96 values)
+   * @return Encoded arguments for use with cloneDeterministicWithImmutableArgs
+   */
+  function encodeImmutableArgs(address _validatorSelection, address[] memory _validators, uint96[] memory _amounts)
+    internal
+    pure
+    returns (bytes memory)
+  {
+    require(
+      _validators.length == _amounts.length, Errors.SlashPayload_ArraySizeMismatch(_validators.length, _amounts.length)
+    );
+
+    // Calculate total size: 20 bytes (address) + 32 bytes (length) + (20 + 12) * length
+    uint256 dataSize = 52 + 32 * _validators.length;
+    bytes memory data = new bytes(dataSize);
+
+    assembly {
+      let ptr := add(data, 0x20)
+
+      // Store validator selection address (20 bytes)
+      // Shift left by 96 bits (12 bytes) to align to the left of the 32-byte slot
+      mstore(ptr, shl(96, _validatorSelection))
+      ptr := add(ptr, 0x14) // Move 20 bytes forward
+
+      // Store array length (32 bytes)
+      mstore(ptr, mload(_validators))
+      ptr := add(ptr, 0x20) // Move 32 bytes forward
+
+      // Store validators and amounts
+      let len := mload(_validators)
+      let validatorsPtr := add(_validators, 0x20)
+      let amountsPtr := add(_amounts, 0x20)
+
+      for { let i := 0 } lt(i, len) { i := add(i, 1) } {
+        // Store validator address (20 bytes)
+        // Shift left by 96 bits to align to the left of the 32-byte slot
+        mstore(ptr, shl(96, mload(add(validatorsPtr, mul(i, 0x20)))))
+        ptr := add(ptr, 0x14) // Move 20 bytes forward
+
+        // Store amount (12 bytes for uint96)
+        // Shift left by 160 bits (20 bytes) to align to the left of the remaining space
+        mstore(ptr, shl(160, mload(add(amountsPtr, mul(i, 0x20)))))
+        ptr := add(ptr, 0x0c) // Move 12 bytes forward
+      }
+    }
+
+    return data;
+  }
+}