@aztec-foundation/l1-artifacts 6.0.0-rc.2 → 6.0.0-rc.4

package/l1-contracts/src/core/interfaces/ISequencerRewardCalculator.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Aztec Labs.
+pragma solidity >=0.8.27;
+
+import {Epoch} from "@aztec/core/libraries/TimeLib.sol";
+
+/**
+ * @title ISequencerRewardCalculator
+ * @author Aztec Labs
+ * @notice Governance-set policy contract that decides the sequencer reward of each newly proven checkpoint.
+ *
+ * @dev The rollup calls {getSequencerRewards} once per epoch proof that newly covers checkpoints, through a
+ *      `staticcall` with a fixed gas stipend of `CALCULATOR_GAS_BASE + CALCULATOR_GAS_PER_CHECKPOINT * n`, where
+ *      `n` is the number of proposers passed. The rollup accepts the response only if the call succeeds, the
+ *      return data is exactly the ABI encoding of a `uint256[]` of length `n` (`64 + 32 * n` bytes, offset 32), and
+ *      every value is at most `MAX_SEQUENCER_REWARD_PER_CHECKPOINT`. Any other outcome, including running out of
+ *      the stipend, pays the default reward to every checkpoint. See `SequencerRewardCalculatorLib`.
+ *
+ *      The calling rollup is `msg.sender`; the calculator MAY read any rollup or GSE state it needs. State is read
+ *      when the proof lands, not when the checkpoints were proposed.
+ */
+interface ISequencerRewardCalculator {
+  /**
+   * @notice Returns the sequencer reward of each newly proven checkpoint of an epoch proof
+   * @dev The rollup passes one entry per checkpoint, including repeated proposers; deduplication, caching and any
+   *      lookups are the calculator's responsibility. MUST be a view.
+   * @param _epoch The epoch whose checkpoints are being rewarded
+   * @param _proposers One attester address per newly proven checkpoint, in checkpoint order
+   * @param _defaultReward The default sequencer reward per checkpoint (`checkpointReward * sequencerBps / 10_000`)
+   * @param _checkpointReward The total checkpoint reward (sequencer share plus prover share)
+   * @return rewards One sequencer reward per entry of `_proposers`, in the same order
+   */
+  function getSequencerRewards(
+    Epoch _epoch,
+    address[] calldata _proposers,
+    uint256 _defaultReward,
+    uint256 _checkpointReward
+  ) external view returns (uint256[] memory rewards);
+}

package/l1-contracts/src/core/interfaces/IValidatorSelection.sol

@@ -7,8 +7,6 @@ import {IEmperor} from "@aztec/governance/interfaces/IEmpire.sol";
 import {Timestamp, Slot, Epoch} from "@aztec/shared/libraries/TimeMath.sol";
 import {Checkpoints} from "@oz/utils/structs/Checkpoints.sol";
 
-uint256 constant MAXIMUM_COMMITTEE_SIZE = 256;
-
 struct ValidatorSelectionStorage {
   // A mapping to snapshots of the validator set
   mapping(Epoch => bytes32 committeeCommitment) committeeCommitments;

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

@@ -238,15 +238,12 @@ library Errors {
   error RewardBooster__InvalidConfig();
 
   error RewardLib__InvalidSequencerBps();
-  error RewardLib__InvalidRegistryRewardOverride(address registry, uint256 sequencerReward);
-  error RewardLib__DuplicateRegistryRewardOverride(address registry);
-  error RewardLib__RegistryRewardOverrideAboveDefault(
-    address registry, uint256 sequencerReward, uint256 defaultSequencerReward
-  );
-  error RewardLib__CheckpointRewardsAboveMaximum(uint256 checkpointRewards, uint256 maximumCheckpointRewards);
   error RewardLib__ZeroShares(address prover);
   error RewardLib__InvalidProtocolFeeRecipient();
 
+  // SequencerRewardCalculatorLib
+  error SequencerRewardCalculatorLib__InsufficientGas(uint256 required, uint256 available);
+
   // SlashingProposer
   error SlashingProposer__InvalidSignature();
   error SlashingProposer__InvalidVoteLength(uint256 expected, uint256 actual);

package/l1-contracts/src/core/libraries/rollup/BlobLib.sol

@@ -114,8 +114,9 @@ library BlobLib {
     // which are different values:
     // - blobsHash := sha256([blobhash_0, ..., blobhash_m]) = a hash of all blob hashes in a checkpoint with m+1 blobs
     // inserted into the header, exists so a user can cross check blobs.
-    // - blobCommitmentsHash := sha256( ...sha256(sha256(C_0), C_1) ... C_n) = iteratively calculated hash of all blob
-    // commitments in an epoch with n+1 blobs (see calculateBlobCommitmentsHash()),
+    // - blobCommitmentsHash := sha256( ...sha256(sha256(s_0, C_0), s_1, C_1) ... s_n, C_n) = iteratively calculated
+    // hash of all blob commitments in an epoch with n+1 blobs, where s_i is the byte 0x01 for each checkpoint's first
+    // blob and 0x00 otherwise (see calculateBlobCommitmentsHash()),
     //   exists so we can validate injected commitments to the rollup circuits correspond to the correct real blobs.
     // We may be able to combine these values e.g. blobCommitmentsHash := sha256( ...sha256(sha256(blobshash_0),
     // blobshash_1) ... blobshash_l) for an epoch with l+1 checkpoints.
@@ -157,11 +158,16 @@ library BlobLib {
    * @param _isFirstCheckpointOfEpoch - Whether this checkpoint is the first of an epoch (see below).
    *
    * The blobCommitmentsHash is an accumulated value calculated in the rollup circuits as:
-   *    blobCommitmentsHash_i := sha256(blobCommitmentsHash_(i - 1), C_i)
+   *    blobCommitmentsHash_i := sha256(blobCommitmentsHash_(i - 1), s_i, C_i)
    * for each blob commitment C_i in an epoch. For the first blob in the epoch (i = 0):
-   *    blobCommitmentsHash_i := sha256(C_0)
+   *    blobCommitmentsHash_i := sha256(0x01, C_0)
    * which is why we require _isFirstCheckpointOfEpoch here.
    *
+   * s_i is one byte (abi.encodePacked encodes a bool as one byte): 0x01 for the first blob of each checkpoint, i.e. the
+   * first commitment passed to each call here, and 0x00 otherwise. The circuits derive it from each checkpoint's own
+   * data, so the final hash binds which checkpoint each blob was proposed with, not only the order of the epoch's
+   * blobs.
+   *
    * Each blob commitment is injected into the rollup circuits and we rely on the L1 contracts to validate
    * these commitments correspond to real blobs. The input _blobCommitments below come from validateBlobs()
    * so we know they are valid commitments here.
@@ -185,10 +191,14 @@ library BlobLib {
     // Blob commitments are collected and proven per root rollup proof => per epoch.
     if (_isFirstCheckpointOfEpoch) {
       // Initialize the blobCommitmentsHash
-      currentBlobCommitmentsHash = Hash.sha256ToField(abi.encodePacked(_blobCommitments[i++]));
+      // true, packed as the byte 0x01: the checkpoint-start flag. The epoch's first blob always starts a checkpoint.
+      currentBlobCommitmentsHash = Hash.sha256ToField(abi.encodePacked(true, _blobCommitments[i++]));
     }
     for (i; i < _blobCommitments.length; i++) {
-      currentBlobCommitmentsHash = Hash.sha256ToField(abi.encodePacked(currentBlobCommitmentsHash, _blobCommitments[i]));
+      // i == 0 flags this proposal's first blob (packed as the byte 0x01, otherwise 0x00), so the hash binds where each
+      // checkpoint's blobs start. The circuits set the same flag on the first blob of each checkpoint they prove.
+      currentBlobCommitmentsHash =
+        Hash.sha256ToField(abi.encodePacked(currentBlobCommitmentsHash, i == 0, _blobCommitments[i]));
     }
   }
 

package/l1-contracts/src/core/libraries/rollup/EpochProofExtLib.sol

@@ -4,7 +4,6 @@ pragma solidity >=0.8.27;
 
 import {SubmitEpochRootProofArgs, PublicInputArgs, RollupConfig} from "@aztec/core/interfaces/IRollup.sol";
 import {ProposedHeader} from "@aztec/core/libraries/rollup/ProposedHeaderLib.sol";
-import {RegistryRewardOverride, MAX_REGISTRY_REWARD_OVERRIDES} from "@aztec/core/libraries/rollup/RewardLib.sol";
 import {EpochProofLib} from "./EpochProofLib.sol";
 
 /**
@@ -21,12 +20,8 @@ import {EpochProofLib} from "./EpochProofLib.sol";
  *      - Epoch proof public input computation
  */
 library EpochProofExtLib {
-  function submitEpochRootProof(
-    SubmitEpochRootProofArgs calldata _args,
-    RollupConfig memory _config,
-    RegistryRewardOverride[MAX_REGISTRY_REWARD_OVERRIDES] memory _registryRewardOverrides
-  ) external {
-    EpochProofLib.submitEpochRootProof(_args, _config, _registryRewardOverrides);
+  function submitEpochRootProof(SubmitEpochRootProofArgs calldata _args, RollupConfig memory _config) external {
+    EpochProofLib.submitEpochRootProof(_args, _config);
   }
 
   function getEpochProofPublicInputs(

package/l1-contracts/src/core/libraries/rollup/EpochProofLib.sol

@@ -19,11 +19,7 @@ import {Constants} from "@aztec/core/libraries/ConstantsGen.sol";
 import {Errors} from "@aztec/core/libraries/Errors.sol";
 import {AttestationLib, CommitteeAttestations} from "@aztec/core/libraries/rollup/AttestationLib.sol";
 import {ProposedHeader, ProposedHeaderLib} from "@aztec/core/libraries/rollup/ProposedHeaderLib.sol";
-import {
-  RewardLib,
-  RegistryRewardOverride,
-  MAX_REGISTRY_REWARD_OVERRIDES
-} from "@aztec/core/libraries/rollup/RewardLib.sol";
+import {RewardLib} from "@aztec/core/libraries/rollup/RewardLib.sol";
 import {STFLib} from "@aztec/core/libraries/rollup/STFLib.sol";
 import {ValidatorSelectionLib} from "@aztec/core/libraries/rollup/ValidatorSelectionLib.sol";
 import {Timestamp, Slot, Epoch, TimeLib} from "@aztec/core/libraries/TimeLib.sol";
@@ -115,11 +111,7 @@ library EpochProofLib {
    *              - proof: The validity proof bytes for the root rollup circuit
    * @param _config The rollup's deployment-time configuration
    */
-  function submitEpochRootProof(
-    SubmitEpochRootProofArgs calldata _args,
-    RollupConfig memory _config,
-    RegistryRewardOverride[MAX_REGISTRY_REWARD_OVERRIDES] memory _registryRewardOverrides
-  ) internal {
+  function submitEpochRootProof(SubmitEpochRootProofArgs calldata _args, RollupConfig memory _config) internal {
     if (STFLib.canPruneAtTime(Timestamp.wrap(block.timestamp))) {
       STFLib.prune();
     }
@@ -189,7 +181,7 @@ library EpochProofLib {
     }
 
     // Activity score depends on whether the proof is a full epoch proof
-    RewardLib.handleRewardsAndFees(_args, endEpoch, _config, fullEpochProof, committee, _registryRewardOverrides);
+    RewardLib.handleRewardsAndFees(_args, endEpoch, _config, fullEpochProof, committee);
 
     emit IRollupCore.L2ProofVerified(_args.end, _args.args.proverId);
   }
@@ -242,7 +234,7 @@ library EpochProofLib {
    *
    * @param _endCheckpointNumber The last checkpoint number in the epoch to verify attestations for
    * @param _attestations The committee attestations containing signatures and validator information
-   * @return The reconstructed committee
+   * @return The reconstructed committee, empty for escape-hatch epochs and zero-size committees
    */
   function verifyLastCheckpointAttestationsAndOutHash(
     uint256 _endCheckpointNumber,

package/l1-contracts/src/core/libraries/rollup/RewardExtLib.sol

@@ -18,13 +18,7 @@ import {
   EthValue
 } from "@aztec/core/libraries/rollup/FeeLib.sol";
 import {ProposeLib} from "@aztec/core/libraries/rollup/ProposeLib.sol";
-import {
-  RewardLib,
-  RewardConfig,
-  MutableRewardConfig,
-  RegistryRewardOverride,
-  MAX_REGISTRY_REWARD_OVERRIDES
-} from "@aztec/core/libraries/rollup/RewardLib.sol";
+import {RewardLib, RewardConfig, MutableRewardConfig} from "@aztec/core/libraries/rollup/RewardLib.sol";
 import {STFLib} from "@aztec/core/libraries/rollup/STFLib.sol";
 import {Epoch, Timestamp} from "@aztec/core/libraries/TimeLib.sol";
 import {
@@ -40,12 +34,14 @@ library RewardExtLib {
   using FeeConfigLib for CompressedFeeConfig;
   using PriceLib for EthValue;
 
-  function initializeConfig(
-    RewardConfig memory _config,
-    RegistryRewardOverride[MAX_REGISTRY_REWARD_OVERRIDES] memory _registryRewardOverrides
-  ) external {
-    RewardLib.validateRegistryRewardOverrides(_registryRewardOverrides, _config);
+  /**
+   * @notice Writes the reward configuration and the initial sequencer reward calculator at construction
+   * @param _config The full reward configuration, including the immutable distributor and booster
+   * @param _sequencerRewardCalculator The initial sequencer reward calculator, or zero for none
+   */
+  function initializeConfig(RewardConfig memory _config, address _sequencerRewardCalculator) external {
     RewardLib.initializeConfig(_config);
+    RewardLib.setSequencerRewardCalculator(_sequencerRewardCalculator);
   }
 
   /**
@@ -89,6 +85,16 @@ library RewardExtLib {
     emit IRollupCore.ProtocolFeeRecipientUpdated(oldRecipient, _recipient);
   }
 
+  /**
+   * @notice Replaces the sequencer reward calculator and emits {IRollupCore.SequencerRewardCalculatorUpdated}
+   * @dev Accepts any address, including zero (no calculator). The event is emitted even if the value is unchanged.
+   * @param _calculator The new calculator, or zero for none
+   */
+  function updateSequencerRewardCalculator(address _calculator) external {
+    address oldCalculator = RewardLib.setSequencerRewardCalculator(_calculator);
+    emit IRollupCore.SequencerRewardCalculatorUpdated(oldCalculator, _calculator);
+  }
+
   function claimSequencerRewards(address _sequencer, IERC20 _feeAsset) external returns (uint256) {
     return RewardLib.claimSequencerRewards(_sequencer, _feeAsset);
   }
@@ -124,6 +130,10 @@ library RewardExtLib {
     return RewardLib.getHasSubmitted(_epoch, _length, _prover);
   }
 
+  function getHasSubmittedFullEpoch(Epoch _epoch, uint256 _length, address _prover) external view returns (bool) {
+    return RewardLib.getHasSubmittedFullEpoch(_epoch, _length, _prover);
+  }
+
   function getHasClaimed(address _prover, Epoch _epoch) external view returns (bool) {
     return RewardLib.getHasClaimed(_prover, _epoch);
   }
@@ -140,6 +150,14 @@ library RewardExtLib {
     return RewardLib.getStorage().config.rewardDistributor;
   }
 
+  /**
+   * @notice Returns the current sequencer reward calculator
+   * @return The calculator, or zero if every checkpoint receives the default sequencer reward
+   */
+  function getSequencerRewardCalculator() external view returns (address) {
+    return RewardLib.getSequencerRewardCalculator();
+  }
+
   // FeeLib/STFLib/ProposeLib view wrappers - overflow from RollupOperationsExtLib
 
   function getManaMinFeeComponentsAt(Timestamp _timestamp, bool _inFeeAsset)