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

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

@@ -6,12 +6,11 @@ import {RollupConfig, SubmitEpochRootProofArgs} from "@aztec/core/interfaces/IRo
 import {CompressedFeeHeader, FeeHeaderLib} from "@aztec/core/libraries/compressed-data/fees/FeeStructs.sol";
 import {Errors} from "@aztec/core/libraries/Errors.sol";
 import {ProposedHeader} from "@aztec/core/libraries/rollup/ProposedHeaderLib.sol";
-import {StakingLib} from "@aztec/core/libraries/rollup/StakingLib.sol";
+import {SequencerRewardCalculatorLib} from "@aztec/core/libraries/rollup/SequencerRewardCalculatorLib.sol";
 import {STFLib} from "@aztec/core/libraries/rollup/STFLib.sol";
 import {ValidatorSelectionLib} from "@aztec/core/libraries/rollup/ValidatorSelectionLib.sol";
 import {Epoch, Timestamp, TimeLib} from "@aztec/core/libraries/TimeLib.sol";
 import {IBoosterCore} from "@aztec/core/reward-boost/RewardBooster.sol";
-import {GSE} from "@aztec/governance/GSE.sol";
 import {IRewardDistributor} from "@aztec/governance/interfaces/IRewardDistributor.sol";
 import {IERC20} from "@oz/token/ERC20/IERC20.sol";
 import {SafeERC20} from "@oz/token/ERC20/utils/SafeERC20.sol";
@@ -21,31 +20,21 @@ import {BitMaps} from "@oz/utils/structs/BitMaps.sol";
 
 type Bps is uint32;
 
-/**
- * @notice The subset of an Aztec Token Position (ATP) staker contract that the reward computation relies on.
- * @dev ATP stakers register themselves as the GSE withdrawer when they deposit, so the withdrawer of an ATP-backed
- *      validator is the staker, not the ATP. The staker only exposes the ATP it belongs to.
- */
-interface IATPStaker {
-  function getATP() external view returns (address);
-}
-
-/**
- * @notice The subset of an Aztec Token Position (ATP) contract that the reward computation relies on.
- */
-interface IATP {
-  function getRegistry() external view returns (address);
-}
-
 library BpsLib {
   function mul(uint256 _a, Bps _b) internal pure returns (uint256) {
     return _a * uint256(Bps.unwrap(_b)) / 10_000;
   }
 }
 
+struct ProverRegistration {
+  uint248 shares;
+  bool fullEpoch; // Set to true when the registration was submitted after the epoch is closed, with a proof of the
+    // full epoch. Used for activity score bumping
+}
+
 struct SubEpochRewards {
   uint256 summedShares;
-  mapping(address prover => uint256 shares) shares;
+  mapping(address prover => ProverRegistration) registrations;
 }
 
 struct EpochRewards {
@@ -54,13 +43,6 @@ struct EpochRewards {
   mapping(uint256 length => SubEpochRewards) subEpoch;
 }
 
-uint256 constant MAX_REGISTRY_REWARD_OVERRIDES = 2;
-
-struct RegistryRewardOverride {
-  address registry;
-  uint96 sequencerReward;
-}
-
 struct RewardConfig {
   IRewardDistributor rewardDistributor;
   Bps sequencerBps;
@@ -82,6 +64,8 @@ struct RewardStorage {
   mapping(address prover => BitMaps.BitMap claimed) proverClaimed;
   RewardConfig config;
   address protocolFeeRecipient;
+  // ISequencerRewardCalculator; zero means every checkpoint receives the default sequencer reward.
+  address sequencerRewardCalculator;
 }
 
 struct Values {
@@ -90,20 +74,17 @@ struct Values {
   uint256 protocolFee;
   uint256 proverFee;
   uint256 sequencerFee;
+  // Default path: every newly proven checkpoint receives this reward.
+  uint256 sequencerCheckpointReward;
+  // Calculator path: one reward per newly proven checkpoint; empty on the default path.
   uint256[] sequencerCheckpointRewards;
   uint256 manaUsed;
 }
 
-struct SequencerRewardContext {
-  uint256[] proposerRewards;
-  uint256 cachedProposers;
-  GSE gse;
-  RegistryRewardOverride[MAX_REGISTRY_REWARD_OVERRIDES] registryRewardOverrides;
-}
-
 struct Totals {
   uint256 feesToClaim;
   uint256 totalProtocolFee;
+  uint256 proverRewards;
 }
 
 library RewardLib {
@@ -116,8 +97,6 @@ library RewardLib {
 
   bytes32 private constant REWARD_STORAGE_POSITION = keccak256("aztec.reward.storage");
 
-  uint256 private constant REGISTRY_PROBE_GAS_LIMIT = 50_000;
-
   /// @notice One-shot writer used during rollup construction. Writes every field of
   ///         {RewardConfig}, including the immutable `rewardDistributor` and `booster`.
   /// @dev Must only be reachable from the constructor path. Post-deployment updates go through
@@ -130,6 +109,17 @@ library RewardLib {
     rewardStorage.protocolFeeRecipient = address(bytes20("CUAUHXICALLI"));
   }
 
+  /// @notice Writes the sequencer reward calculator. The zero address disables it.
+  /// @dev No validation: an address that does not implement the calculator fails the response checks and pays the
+  ///      default, exactly like no calculator.
+  /// @param _calculator The new calculator, or zero for none
+  /// @return oldCalculator The calculator in effect before this call
+  function setSequencerRewardCalculator(address _calculator) internal returns (address oldCalculator) {
+    RewardStorage storage rewardStorage = getStorage();
+    oldCalculator = rewardStorage.sequencerRewardCalculator;
+    rewardStorage.sequencerRewardCalculator = _calculator;
+  }
+
   /// @notice Owner-gated post-deployment writer for the protocol fee recipient.
   /// @param _recipient The new recipient of the protocol fee tranche
   /// @return oldRecipient The recipient in effect before this call
@@ -182,7 +172,7 @@ library RewardLib {
 
       EpochRewards storage e = rewardStorage.epochRewards[_epochs[i]];
       SubEpochRewards storage se = e.subEpoch[e.longestProvenLength];
-      uint256 shares = se.shares[_prover];
+      uint256 shares = se.registrations[_prover].shares;
       if (shares > 0) {
         accumulatedRewards += (shares * e.rewards / se.summedShares);
       }
@@ -195,13 +185,22 @@ library RewardLib {
     return accumulatedRewards;
   }
 
+  /**
+   * @notice Records the prover's shares and, if the proof extends the longest proven prefix of the epoch, pays the
+   *         checkpoint rewards and fees of the newly covered checkpoints.
+   * @param _args The epoch proof submission arguments
+   * @param _endEpoch The epoch being proven
+   * @param _config The rollup's deployment-time configuration
+   * @param _fullEpochProof Whether the proof covers the whole epoch, which updates the prover's activity score
+   * @param _committee The committee the proof's attestations were verified against, in committee order; empty for
+   *        escape-hatch epochs and zero-size committees, which skip the sequencer reward calculator
+   */
   function handleRewardsAndFees(
     SubmitEpochRootProofArgs calldata _args,
     Epoch _endEpoch,
     RollupConfig memory _config,
     bool _fullEpochProof,
-    address[] memory _committee,
-    RegistryRewardOverride[MAX_REGISTRY_REWARD_OVERRIDES] memory _registryRewardOverrides
+    address[] memory _committee
   ) internal {
     RewardStorage storage rewardStorage = getStorage();
 
@@ -212,7 +211,16 @@ library RewardLib {
       SubEpochRewards storage $sr = $er.subEpoch[length];
       address prover = _args.args.proverId;
 
-      require($sr.shares[prover] == 0, Errors.Rollup__ProverHaveAlreadySubmitted(prover, _endEpoch));
+      ProverRegistration memory previousRegistration = $sr.registrations[prover];
+      // There is a point in updating in 2 cases:
+      // 1. This is the first time we are submitting, so shares are at 0
+      // 2. A prover is submitting the same proof a second time after an epoch closed so they would get their activity
+      // score bump. If the second check wasn't there, it would theoretically be possible (but unlikely) to block a
+      // prover from increasing their activity score by submitting a proof for the epoch while it is ongoing
+      require(
+        previousRegistration.shares == 0 || (!previousRegistration.fullEpoch && _fullEpochProof),
+        Errors.Rollup__ProverHaveAlreadySubmitted(prover, _endEpoch)
+      );
       // The prover is only marked active if they have provided a full epoch proof
       uint256 shares = _fullEpochProof
         ? rewardStorage.config.booster.updateAndGetShares(prover)
@@ -225,77 +233,24 @@ library RewardLib {
       // back if a misbehaving booster ever crosses this layer.
       require(shares > 0, Errors.RewardLib__ZeroShares(prover));
 
-      $sr.shares[prover] = shares;
-      $sr.summedShares += shares;
+      $sr.registrations[prover] = ProverRegistration({shares: shares.toUint248(), fullEpoch: _fullEpochProof});
+      $sr.summedShares = $sr.summedShares - previousRegistration.shares + shares;
     }
 
-    if (length > $er.longestProvenLength) {
+    uint256 provenLength = $er.longestProvenLength;
+    if (length > provenLength) {
       Values memory v;
+      Totals memory t;
 
-      {
-        uint256 added = length - $er.longestProvenLength;
-        uint256 checkpointReward = getCheckpointReward();
-        uint256 defaultSequencerRewardPerCheckpoint = BpsLib.mul(checkpointReward, rewardStorage.config.sequencerBps);
-
-        (uint256 desiredSequencerRewardsTotal, uint256[] memory sequencerCheckpointRewards) = computeDesiredSequencerRewards(
-          _args,
-          _endEpoch,
-          _committee,
-          _registryRewardOverrides,
-          $er.longestProvenLength,
-          defaultSequencerRewardPerCheckpoint
-        );
-
-        v.sequencerCheckpointRewards = sequencerCheckpointRewards;
-
-        uint256 proverRewardPerCheckpoint = checkpointReward - defaultSequencerRewardPerCheckpoint;
-        uint256 checkpointRewardsDesired = proverRewardPerCheckpoint * added + desiredSequencerRewardsTotal;
-        uint256 maximumCheckpointRewards = added * checkpointReward;
-
-        require(
-          checkpointRewardsDesired <= maximumCheckpointRewards,
-          Errors.RewardLib__CheckpointRewardsAboveMaximum(checkpointRewardsDesired, maximumCheckpointRewards)
-        );
-
-        uint256 checkpointRewardsAvailable = 0;
-
-        if (checkpointRewardsDesired > 0) {
-          // Cache the reward distributor contract
-          IRewardDistributor distributor = rewardStorage.config.rewardDistributor;
-
-          uint256 amountToClaim = Math.min(checkpointRewardsDesired, distributor.availableTo(address(this)));
-
-          if (amountToClaim > 0) {
-            distributor.claim(address(this), amountToClaim);
-            checkpointRewardsAvailable = amountToClaim;
-          }
-        }
-
-        uint256 sequencerCheckpointRewardTotal = desiredSequencerRewardsTotal;
-        if (checkpointRewardsAvailable < checkpointRewardsDesired) {
-          sequencerCheckpointRewardTotal = 0;
-          for (uint256 i = $er.longestProvenLength; i < length; i++) {
-            uint256 index = i - $er.longestProvenLength;
-            sequencerCheckpointRewards[index] =
-              Math.mulDiv(v.sequencerCheckpointRewards[index], checkpointRewardsAvailable, checkpointRewardsDesired);
-            sequencerCheckpointRewardTotal += v.sequencerCheckpointRewards[index];
-          }
-        }
-
-        uint256 proverCheckpointRewards = checkpointRewardsAvailable - sequencerCheckpointRewardTotal;
-        if (proverCheckpointRewards > 0) {
-          $er.rewards += proverCheckpointRewards.toUint128();
-        }
-      }
+      t.proverRewards =
+        distributeCheckpointRewards(_args, _endEpoch, _committee, provenLength, length - provenLength, v);
 
-      Totals memory t;
-      for (uint256 i = $er.longestProvenLength; i < length; i++) {
+      for (uint256 i = provenLength; i < length; i++) {
         {
           ProposedHeader calldata header = _args.headers[i - _args.provenCheckpointFees.length];
           v.fee = header.accumulatedFees;
           v.sequencer = header.coinbase;
         }
-        uint256 index = i - $er.longestProvenLength;
         CompressedFeeHeader feeHeader = STFLib.getFeeHeader(_args.start + i);
 
         v.manaUsed = feeHeader.getManaUsed();
@@ -306,20 +261,24 @@ library RewardLib {
 
         // Compute the proving fee in the fee asset
         v.proverFee = Math.min(v.manaUsed * feeHeader.getProverCost(), v.fee - v.protocolFee);
-        if (v.proverFee > 0) {
-          $er.rewards += v.proverFee.toUint128();
-        }
+        t.proverRewards += v.proverFee;
 
         v.sequencerFee = v.fee - v.protocolFee - v.proverFee;
 
         {
-          uint256 toSequencer = v.sequencerCheckpointRewards[index] + v.sequencerFee;
+          uint256 toSequencer =
+            (v.sequencerCheckpointRewards.length > 0
+                ? v.sequencerCheckpointRewards[i - provenLength]
+                : v.sequencerCheckpointReward) + v.sequencerFee;
           if (toSequencer > 0) {
             rewardStorage.sequencerRewards[v.sequencer] += toSequencer;
           }
         }
       }
 
+      if (t.proverRewards > 0) {
+        $er.rewards += t.proverRewards.toUint128();
+      }
       $er.longestProvenLength = length.toUint128();
 
       if (t.feesToClaim > 0) {
@@ -349,7 +308,11 @@ library RewardLib {
   }
 
   function getHasSubmitted(Epoch _epoch, uint256 _length, address _prover) internal view returns (bool) {
-    return getStorage().epochRewards[_epoch].subEpoch[_length].shares[_prover] > 0;
+    return getStorage().epochRewards[_epoch].subEpoch[_length].registrations[_prover].shares > 0;
+  }
+
+  function getHasSubmittedFullEpoch(Epoch _epoch, uint256 _length, address _prover) internal view returns (bool) {
+    return getStorage().epochRewards[_epoch].subEpoch[_length].registrations[_prover].fullEpoch;
   }
 
   function getHasClaimed(address _prover, Epoch _epoch) internal view returns (bool) {
@@ -364,6 +327,10 @@ library RewardLib {
     return getStorage().protocolFeeRecipient;
   }
 
+  function getSequencerRewardCalculator() internal view returns (address) {
+    return getStorage().sequencerRewardCalculator;
+  }
+
   function getSpecificProverRewardsForEpoch(Epoch _epoch, address _prover) internal view returns (uint256) {
     RewardStorage storage rewardStorage = getStorage();
 
@@ -376,89 +343,11 @@ library RewardLib {
 
     // Only if prover has shares will he get a reward. Also avoid a 0-div
     // in case of no shares at all.
-    if (se.shares[_prover] == 0) {
+    if (se.registrations[_prover].shares == 0) {
       return 0;
     }
 
-    return (se.shares[_prover] * er.rewards / se.summedShares);
-  }
-
-  /**
-   * @notice Resolves the ATP registry that an attester's withdrawer belongs to.
-   * @dev ATP-backed validators register their staker contract as the GSE withdrawer. The staker exposes the ATP it
-   *      belongs to, and the ATP exposes the registry it was created from, so the lookup is
-   *      `withdrawer.getATP()` followed by `atp.getRegistry()`. Both hops are probed defensively so that arbitrary
-   *      withdrawer contracts cannot make the reward computation revert or burn unbounded gas.
-   * @param _withdrawer The withdrawer registered in the GSE for the attester.
-   * @return responded Whether both hops returned a well-formed address.
-   * @return registry The registry the withdrawer's ATP belongs to, or zero when the lookup did not resolve.
-   */
-  function tryGetRegistry(address _withdrawer) internal view returns (bool responded, address registry) {
-    (bool atpResponded, address atp) = tryGetAddress(_withdrawer, IATPStaker.getATP.selector);
-    if (!atpResponded || atp == address(0)) {
-      return (false, address(0));
-    }
-    return tryGetAddress(atp, IATP.getRegistry.selector);
-  }
-
-  /**
-   * @notice Probes `_target` with a zero-argument view call that is expected to return a single address.
-   * @dev Runs with a fixed gas cap and requires exactly 32 bytes of return data holding a clean address, so a
-   *      misbehaving target can only make the probe fail, never revert the caller or consume unbounded gas.
-   * @param _target The contract to probe. Accounts without code are treated as not responding.
-   * @param _selector The selector of the zero-argument getter to call.
-   * @return responded Whether the call succeeded and returned a well-formed address.
-   * @return result The returned address, or zero when the probe failed.
-   */
-  function tryGetAddress(address _target, bytes4 _selector) internal view returns (bool responded, address result) {
-    if (_target.code.length == 0) {
-      return (false, address(0));
-    }
-
-    uint256 selector = uint32(_selector);
-
-    assembly ("memory-safe") {
-      mstore(0x00, shl(224, selector))
-      let callSucceeded := staticcall(REGISTRY_PROBE_GAS_LIMIT, _target, 0x00, 0x04, 0x20, 0x20)
-      let word := mload(0x20)
-      responded := and(and(callSucceeded, eq(returndatasize(), 0x20)), iszero(shr(160, word)))
-      result := 0
-      if responded {
-        result := and(word, sub(shl(160, 1), 1))
-      }
-    }
-  }
-
-  function validateRegistryRewardOverrides(
-    RegistryRewardOverride[MAX_REGISTRY_REWARD_OVERRIDES] memory _overrides,
-    RewardConfig memory _rewardConfig
-  ) internal pure {
-    uint256 defaultSequencerReward = BpsLib.mul(_rewardConfig.checkpointReward, _rewardConfig.sequencerBps);
-
-    for (uint256 i = 0; i < MAX_REGISTRY_REWARD_OVERRIDES; i++) {
-      RegistryRewardOverride memory current = _overrides[i];
-      if (current.registry == address(0)) {
-        require(
-          current.sequencerReward == 0,
-          Errors.RewardLib__InvalidRegistryRewardOverride(current.registry, current.sequencerReward)
-        );
-        continue;
-      }
-
-      require(
-        current.sequencerReward <= defaultSequencerReward,
-        Errors.RewardLib__RegistryRewardOverrideAboveDefault(
-          current.registry, current.sequencerReward, defaultSequencerReward
-        )
-      );
-
-      for (uint256 j = 0; j < i; j++) {
-        require(
-          _overrides[j].registry != current.registry,
-          Errors.RewardLib__DuplicateRegistryRewardOverride(current.registry)
-        );
-      }
-    }
+    return (se.registrations[_prover].shares * er.rewards / se.summedShares);
   }
 
   function getStorage() internal pure returns (RewardStorage storage storageStruct) {
@@ -468,86 +357,134 @@ library RewardLib {
     }
   }
 
-  function computeDesiredSequencerRewards(
+  /**
+   * @notice Claims the checkpoint rewards of `_added` newly proven checkpoints and splits them between the
+   *         sequencers and the prover pool.
+   *
+   * @dev Without an accepted calculator response (no committee, no calculator, or a failed or malformed call) this
+   *      is the default split, identical to a rollup without a calculator: claim up to `_added * checkpointReward`,
+   *      give the sequencers `sequencerBps` of what was claimed split evenly per checkpoint (written to
+   *      `_v.sequencerCheckpointReward`), and give the prover pool the remainder including the rounding dust.
+   *
+   *      With an accepted response, checkpoint `i` is owed `rewards[i]` and the prover share stays
+   *      `checkpointReward - defaultReward` per checkpoint, so only `Σ rewards + _added * proverShare` is claimed and
+   *      whatever a below-default reward leaves unpaid stays in the distributor. If the distributor holds less, each
+   *      sequencer reward is scaled by `available / desired` and the prover pool receives the remainder, which keeps
+   *      the proportional outcome of the default split. The per-checkpoint rewards are written to
+   *      `_v.sequencerCheckpointRewards`, which stays empty on the default path.
+   *
+   * @return proverRewards The checkpoint rewards that go to the prover pool
+   */
+  function distributeCheckpointRewards(
     SubmitEpochRootProofArgs calldata _args,
     Epoch _endEpoch,
     address[] memory _committee,
-    RegistryRewardOverride[MAX_REGISTRY_REWARD_OVERRIDES] memory _registryRewardOverrides,
-    uint256 _from,
-    uint256 _defaultSequencerRewardPerCheckpoint
-  ) private view returns (uint256, uint256[] memory) {
-    uint256[] memory desiredSequencerCheckpointRewards = new uint256[](_args.end - _args.start + 1 - _from);
-
-    if (_committee.length == 0 || !hasRegistryRewardOverrides(_registryRewardOverrides)) {
-      for (uint256 i = 0; i < desiredSequencerCheckpointRewards.length; i++) {
-        desiredSequencerCheckpointRewards[i] = _defaultSequencerRewardPerCheckpoint;
-      }
-
-      return (
-        _defaultSequencerRewardPerCheckpoint * desiredSequencerCheckpointRewards.length,
-        desiredSequencerCheckpointRewards
+    uint256 _provenLength,
+    uint256 _added,
+    Values memory _v
+  ) private returns (uint256 proverRewards) {
+    RewardStorage storage rewardStorage = getStorage();
+    uint256 checkpointReward = rewardStorage.config.checkpointReward;
+    Bps sequencerBps = rewardStorage.config.sequencerBps;
+
+    uint256 sequencerTotal;
+    uint256 desired;
+    // Escape-hatch epochs and zero-size committees have no proposers to pass, so they never reach the calculator.
+    if (_committee.length > 0 && rewardStorage.sequencerRewardCalculator != address(0)) {
+      uint256 defaultReward = BpsLib.mul(checkpointReward, sequencerBps);
+      sequencerTotal = callSequencerRewardCalculator(
+        _args, _endEpoch, _committee, _provenLength, _added, defaultReward, checkpointReward, _v
       );
+      desired = (checkpointReward - defaultReward) * _added + sequencerTotal;
     }
 
-    uint256 seed = ValidatorSelectionLib.getSampleSeed(_endEpoch);
-    uint256 desiredSequencerRewardsTotal = 0;
-    SequencerRewardContext memory context;
-    context.proposerRewards = new uint256[](_committee.length);
-    context.gse = StakingLib.getStorage().gse;
-    context.registryRewardOverrides = _registryRewardOverrides;
-    _from -= _args.provenCheckpointFees.length;
-    for (uint256 i = 0; i < desiredSequencerCheckpointRewards.length; i++) {
-      uint256 proposerIndex = ValidatorSelectionLib.computeProposerIndex(
-        _endEpoch, _args.headers[_from + i].slotNumber, seed, _committee.length
-      );
-      uint256 proposerMask = uint256(1) << proposerIndex;
-      if (context.cachedProposers & proposerMask == 0) {
-        context.proposerRewards[proposerIndex] = getDesiredSequencerRewardForProposer(
-          _committee[proposerIndex], context, _defaultSequencerRewardPerCheckpoint
-        );
-        context.cachedProposers |= proposerMask;
+    // An accepted response has one entry per newly proven checkpoint, and `_added` is at least one.
+    if (_v.sequencerCheckpointRewards.length > 0) {
+      uint256 available = claimCheckpointRewards(desired);
+      if (available < desired) {
+        uint256[] memory sequencerRewards = _v.sequencerCheckpointRewards;
+        sequencerTotal = 0;
+        for (uint256 i = 0; i < _added; i++) {
+          sequencerRewards[i] = Math.mulDiv(sequencerRewards[i], available, desired);
+          sequencerTotal += sequencerRewards[i];
+        }
       }
-
-      uint256 reward = context.proposerRewards[proposerIndex];
-      desiredSequencerCheckpointRewards[i] = reward;
-      desiredSequencerRewardsTotal += reward;
+      proverRewards = available - sequencerTotal;
+    } else {
+      uint256 available = claimCheckpointRewards(_added * checkpointReward);
+      sequencerTotal = BpsLib.mul(available, sequencerBps);
+      _v.sequencerCheckpointReward = sequencerTotal / _added;
+      uint256 dust = sequencerTotal - (_v.sequencerCheckpointReward * _added);
+      proverRewards = available - sequencerTotal + dust;
     }
-
-    return (desiredSequencerRewardsTotal, desiredSequencerCheckpointRewards);
   }
 
-  function getDesiredSequencerRewardForProposer(
-    address _proposer,
-    SequencerRewardContext memory _context,
-    uint256 _defaultSequencerRewardPerCheckpoint
-  ) private view returns (uint256) {
-    address withdrawer = _context.gse.getWithdrawer(_proposer);
-    (bool responded, address registry) = tryGetRegistry(withdrawer);
-    if (!responded || registry == address(0)) {
-      return _defaultSequencerRewardPerCheckpoint;
-    }
-
-    for (uint256 i = 0; i < MAX_REGISTRY_REWARD_OVERRIDES; i++) {
-      RegistryRewardOverride memory current = _context.registryRewardOverrides[i];
-      if (current.registry == registry) {
-        return Math.min(_defaultSequencerRewardPerCheckpoint, current.sequencerReward);
+  /**
+   * @notice Claims up to `_desired` from the reward distributor
+   * @return available The amount claimed: `_desired`, or what the distributor holds for this rollup if less
+   */
+  function claimCheckpointRewards(uint256 _desired) private returns (uint256 available) {
+    if (_desired > 0) {
+      IRewardDistributor distributor = getStorage().config.rewardDistributor;
+      available = Math.min(_desired, distributor.availableTo(address(this)));
+      if (available > 0) {
+        distributor.claim(address(this), available);
       }
     }
-
-    return _defaultSequencerRewardPerCheckpoint;
   }
 
-  function hasRegistryRewardOverrides(RegistryRewardOverride[MAX_REGISTRY_REWARD_OVERRIDES] memory _registryRewardOverrides)
-    private
-    pure
-    returns (bool)
-  {
-    for (uint256 i = 0; i < MAX_REGISTRY_REWARD_OVERRIDES; i++) {
-      if (_registryRewardOverrides[i].registry != address(0)) {
-        return true;
-      }
+  /**
+   * @notice Asks the sequencer reward calculator for the reward of each newly proven checkpoint
+   * @dev On an accepted response, writes the rewards to `_v.sequencerCheckpointRewards` and returns their sum. On any
+   *      failure, leaves `_v.sequencerCheckpointRewards` empty so the caller falls back to the default path.
+   * @return total The sum of the accepted rewards, or zero
+   */
+  function callSequencerRewardCalculator(
+    SubmitEpochRootProofArgs calldata _args,
+    Epoch _endEpoch,
+    address[] memory _committee,
+    uint256 _provenLength,
+    uint256 _added,
+    uint256 _defaultReward,
+    uint256 _checkpointReward,
+    Values memory _v
+  ) private view returns (uint256 total) {
+    (bool accepted, uint256[] memory rewards, uint256 sum) = SequencerRewardCalculatorLib.tryGetSequencerRewards(
+      getStorage().sequencerRewardCalculator,
+      _endEpoch,
+      getProposers(_args, _endEpoch, _committee, _provenLength, _added),
+      _defaultReward,
+      _checkpointReward
+    );
+    if (accepted) {
+      _v.sequencerCheckpointRewards = rewards;
+      total = sum;
     }
+  }
 
-    return false;
+  /**
+   * @notice Derives the proposer of each newly proven checkpoint from the committee the proof verified
+   * @dev Mirrors the proposer selection at propose time: `computeProposerIndex(epoch, slot, sampleSeed, size)`. The
+   *      headers of every rewarded checkpoint are present and were bound to the stored header hashes by the proof.
+   * @return proposers One committee member per newly proven checkpoint, in checkpoint order
+   */
+  function getProposers(
+    SubmitEpochRootProofArgs calldata _args,
+    Epoch _endEpoch,
+    address[] memory _committee,
+    uint256 _provenLength,
+    uint256 _added
+  ) private view returns (address[] memory proposers) {
+    proposers = new address[](_added);
+    uint256 seed = ValidatorSelectionLib.getSampleSeed(_endEpoch);
+    uint256 committeeSize = _committee.length;
+    uint256 firstHeader = _provenLength - _args.provenCheckpointFees.length;
+    for (uint256 i = 0; i < _added; i++) {
+      proposers[i] = _committee[
+        ValidatorSelectionLib.computeProposerIndex(
+          _endEpoch, _args.headers[firstHeader + i].slotNumber, seed, committeeSize
+        )
+      ];
+    }
   }
 }