feat: remove isRewardClaimable

Author: LHerskind

docs/docs-operate/operators/sequencer-management/claiming-rewards.md

@@ -37,9 +37,8 @@ Rewards are not automatically sent to your coinbase address. You must explicitly
 
 Before claiming, verify these conditions:
 
-1. **Rewards must be claimable**: A governance vote must pass to enable the claiming of rewards (only possible after a minimum configured timestamp) and governance must have called `setRewardsClaimable(true)` on the rollup contract.
-2. **Rewards have accumulated**: Query your pending rewards before attempting to claim.
-3. **Sufficient gas**: Ensure you have ETH to pay transaction gas costs.
+1. **Rewards have accumulated**: Query your pending rewards before attempting to claim.
+2. **Sufficient gas**: Ensure you have ETH to pay transaction gas costs.
 
 ## Checking Reward Status
 
@@ -54,26 +53,6 @@ export ROLLUP_ADDRESS="[YOUR_ROLLUP_CONTRACT_ADDRESS]"
 
 Replace `[YOUR_ROLLUP_CONTRACT_ADDRESS]` with your actual Rollup contract address.
 
-### Check if Rewards Are Claimable
-
-Verify reward claiming is enabled before attempting to claim:
-
-```bash
-cast call $ROLLUP_ADDRESS "isRewardsClaimable()" --rpc-url $RPC_URL
-```
-
-**Expected output:**
-- `0x0000000000000000000000000000000000000000000000000000000000000001` - Rewards are claimable (true)
-- `0x0000000000000000000000000000000000000000000000000000000000000000` - Rewards are not yet claimable (false)
-
-If rewards are not claimable, check when they will become claimable:
-
-```bash
-cast call $ROLLUP_ADDRESS "getEarliestRewardsClaimableTimestamp()" --rpc-url $RPC_URL
-```
-
-This returns a Unix timestamp indicating the earliest time when governance can enable reward claiming.
-
 ### Query Your Pending Rewards
 
 Check accumulated rewards:
@@ -161,15 +140,6 @@ cast call $ROLLUP_ADDRESS "getSequencerRewards(address)" [COINBASE_ADDRESS] --rp
 
 ## Troubleshooting
 
-### "Rewards not claimable" Error
-
-**Symptom**: Transaction reverts with "Rewards not claimable" error.
-
-**Solution**:
-1. Check if rewards are claimable using `isRewardsClaimable()`
-2. If `false`, wait until governance enables claiming via `setRewardsClaimable(true)`
-3. Check the earliest claimable timestamp using `getEarliestRewardsClaimableTimestamp()`
-
 ### No Pending Rewards
 
 **Symptom**: `getSequencerRewards()` returns zero.

l1-contracts/script/deploy/RollupConfiguration.sol

@@ -11,7 +11,6 @@ import {IBoosterCore} from "@aztec/core/reward-boost/RewardBooster.sol";
 import {SlasherFlavor} from "@aztec/core/interfaces/ISlasher.sol";
 import {EthValue, EthPerFeeAssetE12} from "@aztec/core/libraries/rollup/FeeLib.sol";
 import {GenesisState, RollupConfigInput} from "@aztec/core/interfaces/IRollup.sol";
-import {Timestamp} from "@aztec/core/libraries/TimeLib.sol";
 import {RewardBoostConfig} from "@aztec/core/reward-boost/RewardBooster.sol";
 import {StakingQueueConfig} from "@aztec/core/libraries/compressed-data/StakingQueueConfig.sol";
 import {RewardConfig, Bps} from "@aztec/core/libraries/rollup/RewardLib.sol";
@@ -20,7 +19,6 @@ interface IRollupConfiguration {
   function loadConfig() external;
   function useRealVerifier() external view returns (bool);
   function getFeeJuicePortalInitialBalance() external view returns (uint256);
-  function getEarliestRewardsClaimableTimestamp() external view returns (Timestamp);
   function getGenesisState() external view returns (GenesisState memory);
   function getRewardConfiguration(IRewardDistributor rewardDistributor) external view returns (RewardConfig memory);
   function getRewardBoostConfiguration() external pure returns (RewardBoostConfig memory);
@@ -49,16 +47,6 @@ contract RollupConfiguration is IRollupConfiguration, Test {
     return vm.envOr("FEE_JUICE_PORTAL_INITIAL_BALANCE", uint256(0));
   }
 
-  function getEarliestRewardsClaimableTimestamp() public view returns (Timestamp) {
-    // We only set a delay on mainnet.
-    // Since we don't plan to redeploy on mainnet (knock on wood), this is mostly documentation in code form.
-    if (block.chainid == 1) {
-      return Timestamp.wrap(block.timestamp + 90 days);
-    } else {
-      return Timestamp.wrap(0);
-    }
-  }
-
   function getGenesisState() external view returns (GenesisState memory) {
     return GenesisState({
       vkTreeRoot: bytes32(vm.envOr("VK_TREE_ROOT", uint256(0))),
@@ -106,7 +94,6 @@ contract RollupConfiguration is IRollupConfiguration, Test {
     config.rewardConfig = this.getRewardConfiguration(_rewardDistributor);
     config.rewardBoostConfig = this.getRewardBoostConfiguration();
     config.stakingQueueConfig = this.getStakingQueueConfiguration();
-    config.earliestRewardsClaimableTimestamp = getEarliestRewardsClaimableTimestamp();
 
     // Compute version as first 4 bytes of hash(abi.encode(config, genesisState))
     config.version = _computeConfigVersion(config, this.getGenesisState());

l1-contracts/src/core/Rollup.sol

@@ -570,14 +570,6 @@ contract Rollup is IStaking, IValidatorSelection, IRollup, RollupCore {
     return RewardExtLib.getCheckpointReward();
   }
 
-  function isRewardsClaimable() external view override(IRollup) returns (bool) {
-    return RewardExtLib.isRewardsClaimable();
-  }
-
-  function getEarliestRewardsClaimableTimestamp() external view override(IRollup) returns (Timestamp) {
-    return RewardExtLib.getEarliestRewardsClaimableTimestamp();
-  }
-
   function getAvailableValidatorFlushes() external view override(IStaking) returns (uint256) {
     return ValidatorOperationsExtLib.getAvailableValidatorFlushes();
   }

l1-contracts/src/core/RollupCore.sol

@@ -282,17 +282,6 @@ contract RollupCore is EIP712("Aztec Rollup", "1"), Ownable, IStakingCore, IVali
     emit IRollupCore.ManaTargetUpdated(_manaTarget);
   }
 
-  /**
-   * @notice Enables or disables reward claiming
-   * @dev Only callable by owner. This is a safety mechanism to control when rewards can be withdrawn.
-   *      Cannot set rewards as claimable before the earliest reward claimable timestamp.
-   * @param _isRewardsClaimable True to enable reward claims, false to disable
-   */
-  function setRewardsClaimable(bool _isRewardsClaimable) external override(IRollupCore) onlyOwner {
-    RewardExtLib.setIsRewardsClaimable(_isRewardsClaimable);
-    emit RewardsClaimableUpdated(_isRewardsClaimable);
-  }
-
   /**
    * @notice Updates the slasher contract address
    * @dev Only callable by owner. The slasher handles punishment for validator misbehavior.
@@ -343,7 +332,7 @@ contract RollupCore is EIP712("Aztec Rollup", "1"), Ownable, IStakingCore, IVali
 
   /**
    * @notice Claims accumulated rewards for a sequencer (checkpoint proposer)
-   * @dev Rewards must be enabled via isRewardsClaimable. Transfers all accumulated rewards to the recipient.
+   * @dev Transfers all accumulated rewards to the recipient.
    * @param _coinbase The address that has accumulated the rewards - rewards are sent to this address
    * @return The amount of rewards claimed
    */
@@ -353,8 +342,8 @@ contract RollupCore is EIP712("Aztec Rollup", "1"), Ownable, IStakingCore, IVali
 
   /**
    * @notice Claims prover rewards for specified epochs
-   * @dev Rewards must be enabled. Provers earn rewards for successfully proving epoch transitions.
-   *      Each epoch can only be claimed once per prover.
+   * @dev Provers earn rewards for successfully proving epoch transitions. Each epoch can only be claimed once per
+   *      prover.
    * @param _coinbase The address that has accumulated the rewards - rewards are sent to this address
    * @param _epochs Array of epochs to claim rewards for
    * @return The total amount of rewards claimed
@@ -607,7 +596,6 @@ contract RollupCore is EIP712("Aztec Rollup", "1"), Ownable, IStakingCore, IVali
       rewardConfig.booster = RewardExtLib.deployRewardBooster(_config.rewardBoostConfig);
     }
 
-    RewardExtLib.initialize(_config.earliestRewardsClaimableTimestamp);
     RewardExtLib.setConfig(rewardConfig);
   }
 

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

@@ -80,7 +80,6 @@ struct RollupConfigInput {
   RewardBoostConfig rewardBoostConfig;
   StakingQueueConfig stakingQueueConfig;
   uint256 localEjectionThreshold;
-  Timestamp earliestRewardsClaimableTimestamp;
   uint256 inboxLag;
 }
 
@@ -116,9 +115,7 @@ interface IRollupCore {
   event RewardConfigUpdated(RewardConfig rewardConfig);
   event ManaTargetUpdated(uint256 indexed manaTarget);
   event PrunedPending(uint256 provenCheckpointNumber, uint256 pendingCheckpointNumber);
-  event RewardsClaimableUpdated(bool isRewardsClaimable);
 
-  function setRewardsClaimable(bool _isRewardsClaimable) external;
   function claimSequencerRewards(address _recipient) external returns (uint256);
   function claimProverRewards(address _recipient, Epoch[] memory _epochs) external returns (uint256);
 
@@ -238,6 +235,4 @@ interface IRollup is IRollupCore, IHaveVersion {
 
   function getRewardConfig() external view returns (RewardConfig memory);
   function getCheckpointReward() external view returns (uint256);
-  function getEarliestRewardsClaimableTimestamp() external view returns (Timestamp);
-  function isRewardsClaimable() external view returns (bool);
 }

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

@@ -87,8 +87,6 @@ library Errors {
   error Rollup__ProverHaveAlreadySubmitted(address prover, Epoch epoch);
   error Rollup__InvalidManaTarget(uint256 minimum, uint256 provided);
   error Rollup__ManaLimitExceeded();
-  error Rollup__RewardsNotClaimable();
-  error Rollup__TooSoonToSetRewardsClaimable(uint256 earliestRewardsClaimableTimestamp, uint256 currentTimestamp);
   error Rollup__InvalidFirstEpochProof();
   error Rollup__InvalidCoinbase();
   error Rollup__UnavailableTempCheckpointLog(

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

@@ -22,18 +22,10 @@ import {
 import {IRewardDistributor} from "@aztec/governance/interfaces/IRewardDistributor.sol";
 
 library RewardExtLib {
-  function initialize(Timestamp _earliestRewardsClaimableTimestamp) external {
-    RewardLib.initialize(_earliestRewardsClaimableTimestamp);
-  }
-
   function setConfig(RewardConfig memory _config) external {
     RewardLib.setConfig(_config);
   }
 
-  function setIsRewardsClaimable(bool _isRewardsClaimable) external {
-    RewardLib.setIsRewardsClaimable(_isRewardsClaimable);
-  }
-
   function claimSequencerRewards(address _sequencer) external returns (uint256) {
     return RewardLib.claimSequencerRewards(_sequencer);
   }
@@ -77,14 +69,6 @@ library RewardExtLib {
     return RewardLib.getCheckpointReward();
   }
 
-  function isRewardsClaimable() external view returns (bool) {
-    return RewardLib.isRewardsClaimable();
-  }
-
-  function getEarliestRewardsClaimableTimestamp() external view returns (Timestamp) {
-    return RewardLib.getEarliestRewardsClaimableTimestamp();
-  }
-
   function getRewardConfig() external view returns (RewardConfig memory) {
     return RewardLib.getStorage().config;
   }

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

@@ -9,7 +9,6 @@ import {STFLib} from "@aztec/core/libraries/rollup/STFLib.sol";
 import {Epoch, Timestamp, TimeLib} from "@aztec/core/libraries/TimeLib.sol";
 import {IBoosterCore} from "@aztec/core/reward-boost/RewardBooster.sol";
 import {IRewardDistributor} from "@aztec/governance/interfaces/IRewardDistributor.sol";
-import {CompressedTimeMath, CompressedTimestamp} from "@aztec/shared/libraries/CompressedTimeMath.sol";
 import {IERC20} from "@oz/token/ERC20/IERC20.sol";
 import {SafeERC20} from "@oz/token/ERC20/utils/SafeERC20.sol";
 import {Math} from "@oz/utils/math/Math.sol";
@@ -47,8 +46,6 @@ struct RewardStorage {
   mapping(Epoch => EpochRewards) epochRewards;
   mapping(address prover => BitMaps.BitMap claimed) proverClaimed;
   RewardConfig config;
-  CompressedTimestamp earliestRewardsClaimableTimestamp;
-  bool isRewardsClaimable;
 }
 
 struct Values {
@@ -67,8 +64,6 @@ struct Totals {
 library RewardLib {
   using SafeERC20 for IERC20;
   using BitMaps for BitMaps.BitMap;
-  using CompressedTimeMath for CompressedTimestamp;
-  using CompressedTimeMath for Timestamp;
   using TimeLib for Timestamp;
   using TimeLib for Epoch;
   using FeeHeaderLib for CompressedFeeHeader;
@@ -81,34 +76,14 @@ library RewardLib {
   // such as sacrificial hearts, during rituals performed within temples.
   address public constant BURN_ADDRESS = address(bytes20("CUAUHXICALLI"));
 
-  function initialize(Timestamp _earliestRewardsClaimableTimestamp) internal {
-    RewardStorage storage rewardStorage = getStorage();
-    rewardStorage.earliestRewardsClaimableTimestamp = _earliestRewardsClaimableTimestamp.compress();
-    rewardStorage.isRewardsClaimable = false;
-  }
-
   function setConfig(RewardConfig memory _config) internal {
     require(Bps.unwrap(_config.sequencerBps) <= 10_000, Errors.RewardLib__InvalidSequencerBps());
     RewardStorage storage rewardStorage = getStorage();
     rewardStorage.config = _config;
   }
 
-  function setIsRewardsClaimable(bool _isRewardsClaimable) internal {
-    RewardStorage storage rewardStorage = getStorage();
-    uint256 earliestRewardsClaimableTimestamp =
-      Timestamp.unwrap(rewardStorage.earliestRewardsClaimableTimestamp.decompress());
-    require(
-      block.timestamp >= earliestRewardsClaimableTimestamp,
-      Errors.Rollup__TooSoonToSetRewardsClaimable(earliestRewardsClaimableTimestamp, block.timestamp)
-    );
-
-    rewardStorage.isRewardsClaimable = _isRewardsClaimable;
-  }
-
   function claimSequencerRewards(address _sequencer) internal returns (uint256) {
     RewardStorage storage rewardStorage = getStorage();
-    require(rewardStorage.isRewardsClaimable, Errors.Rollup__RewardsNotClaimable());
-
     RollupStore storage rollupStore = STFLib.getStorage();
     uint256 amount = rewardStorage.sequencerRewards[_sequencer];
 
@@ -126,8 +101,6 @@ library RewardLib {
 
     RewardStorage storage rewardStorage = getStorage();
 
-    require(rewardStorage.isRewardsClaimable, Errors.Rollup__RewardsNotClaimable());
-
     uint256 accumulatedRewards = 0;
     for (uint256 i = 0; i < _epochs.length; i++) {
       require(
@@ -296,14 +269,6 @@ library RewardLib {
     return (se.shares[_prover] * er.rewards / se.summedShares);
   }
 
-  function isRewardsClaimable() internal view returns (bool) {
-    return getStorage().isRewardsClaimable;
-  }
-
-  function getEarliestRewardsClaimableTimestamp() internal view returns (Timestamp) {
-    return getStorage().earliestRewardsClaimableTimestamp.decompress();
-  }
-
   function getStorage() internal pure returns (RewardStorage storage storageStruct) {
     bytes32 position = REWARD_STORAGE_POSITION;
     assembly {

l1-contracts/src/periphery/FlushRewarder.sol

@@ -3,7 +3,6 @@
 pragma solidity >=0.8.27;
 
 import {IInstance} from "@aztec/core/interfaces/IInstance.sol";
-import {Errors} from "@aztec/core/libraries/Errors.sol";
 import {Ownable} from "@oz/access/Ownable.sol";
 import {IERC20} from "@oz/token/ERC20/IERC20.sol";
 import {SafeERC20} from "@oz/token/ERC20/utils/SafeERC20.sol";
@@ -47,8 +46,6 @@ contract FlushRewarder is Ownable, IFlushRewarder {
   }
 
   function claimRewards() external override(IFlushRewarder) {
-    require(ROLLUP.isRewardsClaimable(), Errors.Rollup__RewardsNotClaimable());
-
     uint256 rewardsToClaim = rewardsOf[msg.sender];
     if (rewardsToClaim > 0) {
       rewardsOf[msg.sender] = 0;

l1-contracts/test/MultiProof.t.sol

@@ -4,11 +4,9 @@ pragma solidity >=0.8.27;
 
 import {DecoderBase} from "./base/DecoderBase.sol";
 
-import {Registry} from "@aztec/governance/Registry.sol";
 import {FeeJuicePortal} from "@aztec/core/messagebridge/FeeJuicePortal.sol";
 import {TestERC20} from "@aztec/mock/TestERC20.sol";
 import {TestConstants} from "./harnesses/TestConstants.sol";
-import {RewardDistributor} from "@aztec/governance/RewardDistributor.sol";
 import {ProposeArgs, ProposeLib} from "@aztec/core/libraries/rollup/ProposeLib.sol";
 
 import {Timestamp, Slot, Epoch, TimeLib} from "@aztec/core/libraries/TimeLib.sol";
@@ -18,7 +16,6 @@ import {Errors} from "@aztec/core/libraries/Errors.sol";
 
 import {RollupBase, IInstance} from "./base/RollupBase.sol";
 import {RollupBuilder} from "./builder/RollupBuilder.sol";
-import {Ownable} from "@oz/access/Ownable.sol";
 import {stdStorage, StdStorage} from "forge-std/StdStorage.sol";
 import {RewardBooster, ActivityScore} from "@aztec/core/reward-boost/RewardBooster.sol";
 import {BoostedHelper} from "./boosted_rewards/BoostRewardHelper.sol";
@@ -36,10 +33,8 @@ contract MultiProofTest is RollupBase {
   using TimeLib for Slot;
   using TimeLib for Epoch;
 
-  Registry internal registry;
   TestERC20 internal testERC20;
   FeeJuicePortal internal feeJuicePortal;
-  RewardDistributor internal rewardDistributor;
   RewardBooster internal rewardBooster;
 
   uint256 internal SLOT_DURATION;
@@ -145,18 +140,6 @@ contract MultiProofTest is RollupBase {
 
     assertEq(rollup.getProvenCheckpointNumber(), 2, "Checkpoint not proven");
 
-    {
-      // Ensure that we cannot claim rewards when not toggled yet
-      vm.expectRevert(abi.encodeWithSelector(Errors.Rollup__RewardsNotClaimable.selector));
-      rollup.claimSequencerRewards(sequencer);
-
-      vm.expectRevert(abi.encodeWithSelector(Errors.Rollup__RewardsNotClaimable.selector));
-      rollup.claimProverRewards(alice, new Epoch[](1));
-
-      vm.prank(Ownable(address(rollup)).owner());
-      rollup.setRewardsClaimable(true);
-    }
-
     {
       uint256 sequencerRewards = rollup.getSequencerRewards(sequencer);
       assertGt(sequencerRewards, 0, "Sequencer rewards is zero");