feat: reimplement validator rewarder (#69)

This PR reimplements validator rewarder contract according to a fixed
token increments. Please checkout the discussion here for more details
about the current implementation:
recallnet/ipc#151 (comment)


With these changes there won't be any "state" in the rewarder contract.
The overall architecture remains the same. That is the validator
rewarder is being called by the IPC when there is a new claim for
rewards. We assume that IPC guarantees that there won't be any "double
claiming". IPC notifies the validator rewarder with the checkpoint
height, validator's address and the number of blocks that _this_
validator has committed in the checkpoint.

Each checkpoint contains 600 blocks. Which means 200 new tokens (1 token
per 3 blocks) are minted in each checkpoint. We just calculate the
validator's share of these 200 new tokens i.e. the ratio of blocks that
they have committed to total blocks in the checkpoint. We mint this
amount to validator's address.

---------

Signed-off-by: avichalp <[email protected]>

Author: avichalp

foundry.toml

@@ -2,6 +2,7 @@
 src = "src"
 out = "out"
 libs = ["lib"]
+fs_permissions = [{ access = "read", path = "./out" }]
 test = "test"
 build_info = true
 extra_output = ["storageLayout"]

src/token/ValidatorRewarder.sol

@@ -32,28 +32,22 @@ contract ValidatorRewarder is IValidatorRewarder, UUPSUpgradeable, OwnableUpgrad
     /// @notice The token that this rewarder mints
     Recall public token;
 
-    /// @notice The latest checkpoint height that rewards can be claimed for
-    /// @dev Using uint64 to match Filecoin's epoch height type and save gas when interacting with the network
-    uint64 public latestClaimedCheckpoint;
-
     /// @notice The bottomup checkpoint period for the subnet.
     /// @dev The checkpoint period is set when the subnet is created.
     uint256 public checkpointPeriod;
 
-    /// @notice The supply of RECALL tokens at each checkpoint
-    mapping(uint64 checkpointHeight => uint256 totalSupply) public checkpointToSupply;
-
-    /// @notice The inflation rate for the subnet
-    /// @dev The rate is expressed as a decimal*1e18.
-    /// @dev For example 5% APY is 0.0000928276004952% yield per checkpoint period.
-    /// @dev This is expressed as 928_276_004_952 or 0.000000928276004952*1e18.
-    uint256 public constant INFLATION_RATE = 928_276_004_952;
+    /// @notice The number of blocks required to generate 1 new token (with 18 decimals)
+    uint256 public constant BLOCKS_PER_TOKEN = 3;
 
     // ========== EVENTS & ERRORS ==========
 
     event ActiveStateChange(bool active, address account);
     event SubnetUpdated(SubnetID subnet, uint256 checkpointPeriod);
-    event CheckpointClaimed(uint64 indexed checkpointHeight, address indexed validator, uint256 amount);
+    /// @notice Emitted when a validator claims their rewards for a checkpoint
+    /// @param checkpointHeight The height of the checkpoint for which rewards are claimed
+    /// @param validator The address of the validator claiming rewards
+    /// @param amount The amount of tokens claimed as reward
+    event RewardsClaimed(uint64 indexed checkpointHeight, address indexed validator, uint256 amount);
 
     error SubnetMismatch(SubnetID id);
     error InvalidClaimNotifier(address notifier);
@@ -136,83 +130,52 @@ contract ValidatorRewarder is IValidatorRewarder, UUPSUpgradeable, OwnableUpgrad
             revert InvalidClaimNotifier(msg.sender);
         }
 
-        // When the supply for the checkpoint is 0, it means that this is the first claim
-        // for this checkpoint.
-        // In this case we will set the supply for the checkpoint and
-        // calculate the inflation and mint the rewards to the rewarder and the first claimant.
-        // Otherwise, we know the supply for the checkpoint.
-        // We will calculate the rewards and transfer them to the other claimants for this checkpoint.
-        uint256 supplyAtCheckpoint = checkpointToSupply[claimedCheckpointHeight];
-        if (supplyAtCheckpoint == 0) {
-            // Check that the checkpoint height is valid.
-            if (!validateCheckpointHeight(claimedCheckpointHeight)) {
-                revert InvalidCheckpointHeight(claimedCheckpointHeight);
-            }
-
-            // Get the current supply of RECALL tokens
-            uint256 currentSupply = token.totalSupply();
-
-            // Set the supply for the checkpoint and update latest claimed checkpoint
-            checkpointToSupply[claimedCheckpointHeight] = currentSupply;
-            latestClaimedCheckpoint = claimedCheckpointHeight;
-
-            // Calculate rewards
-            uint256 supplyDelta = calculateInflationForCheckpoint(currentSupply);
-            uint256 validatorShare = calculateValidatorShare(data.blocksCommitted, supplyDelta);
-
-            // Perform external interactions after state updates
-            token.mint(address(this), supplyDelta - validatorShare);
-            token.mint(data.validator, validatorShare);
-            emit CheckpointClaimed(claimedCheckpointHeight, data.validator, validatorShare);
-        } else {
-            // Calculate the supply delta for the checkpoint
-            uint256 supplyDelta = calculateInflationForCheckpoint(supplyAtCheckpoint);
-            // Calculate the validator's share of the supply delta
-            uint256 validatorShare = calculateValidatorShare(data.blocksCommitted, supplyDelta);
-            // Transfer the validator's share of the supply delta to the validator
-            token.safeTransfer(data.validator, validatorShare);
-            emit CheckpointClaimed(claimedCheckpointHeight, data.validator, validatorShare);
+        // Check that the checkpoint height is valid
+        if (!validateCheckpointHeight(claimedCheckpointHeight)) {
+            revert InvalidCheckpointHeight(claimedCheckpointHeight);
         }
+
+        // Calculate rewards for this checkpoint
+        uint256 newTokens = calculateNewTokensForCheckpoint();
+        uint256 validatorShare = calculateValidatorShare(data.blocksCommitted, newTokens);
+
+        // Mint the validator's share
+        token.mint(data.validator, validatorShare);
+        emit RewardsClaimed(claimedCheckpointHeight, data.validator, validatorShare);
     }
 
     // ========== INTERNAL FUNCTIONS ==========
 
-    /// @notice The internal method to calculate the supply delta for a checkpoint
-    /// @param supply The token supply at the checkpoint
-    /// @return The supply delta, i.e. the amount of new tokens minted for the checkpoint
-    function calculateInflationForCheckpoint(uint256 supply) internal pure returns (uint256) {
-        UD60x18 supplyFixed = ud(supply);
-        UD60x18 inflationRateFixed = ud(INFLATION_RATE);
-        UD60x18 result = supplyFixed.mul(inflationRateFixed);
-        return result.unwrap();
+    /// @notice Calculates the total number of new tokens to be minted for a checkpoint
+    /// @return The number of new tokens to be minted (in base units with 18 decimals)
+    function calculateNewTokensForCheckpoint() internal view returns (uint256) {
+        UD60x18 blocksPerToken = ud(BLOCKS_PER_TOKEN);
+        UD60x18 period = ud(checkpointPeriod);
+        UD60x18 oneToken = ud(1 ether);
+
+        // Calculate (checkpointPeriod * 1 ether) / BLOCKS_PER_TOKEN using fixed-point math
+        return period.mul(oneToken).div(blocksPerToken).unwrap();
     }
 
-    /// @notice The internal method to calculate the validator's share of the supply delta
+    /// @notice The internal method to calculate the validator's share of the new tokens
     /// @param blocksCommitted The number of blocks committed by the validator
-    /// @param supplyDelta The supply delta, i.e. the amount of new tokens minted for the checkpoint
-    /// @return The validator's share of the supply delta
-    function calculateValidatorShare(uint256 blocksCommitted, uint256 supplyDelta) internal view returns (uint256) {
-        UD60x18 blocksFixed = ud(blocksCommitted);
-        UD60x18 deltaFixed = ud(supplyDelta);
-        UD60x18 periodFixed = ud(checkpointPeriod);
-        UD60x18 share = blocksFixed.div(periodFixed);
-        UD60x18 result = share.mul(deltaFixed);
+    /// @param totalNewTokens The total number of new tokens for the checkpoint
+    /// @return The validator's share of the new tokens
+    function calculateValidatorShare(uint256 blocksCommitted, uint256 totalNewTokens) internal view returns (uint256) {
+        UD60x18 blocks = ud(blocksCommitted);
+        UD60x18 tokens = ud(totalNewTokens);
+        UD60x18 period = ud(checkpointPeriod);
+        UD60x18 share = blocks.div(period);
+        UD60x18 result = share.mul(tokens);
         return result.unwrap();
     }
 
     /// @notice Validates that the claimed checkpoint height is valid
     /// @param claimedCheckpointHeight The height of the checkpoint that the validator is claiming for
     /// @return True if the checkpoint height is valid, false otherwise
-    /// @dev When the latest claimable checkpoint is not set (0), it means that _this_ is the first ever claim.
-    /// @dev In this case, we need to ensure the first claim is at the first checkpoint period.
-    /// @dev Otherwise, we must ensure that the claimed checkpoint is the next expected checkpoint.
+    /// @dev Ensures the checkpoint height is a multiple of the checkpoint period
     function validateCheckpointHeight(uint64 claimedCheckpointHeight) internal view returns (bool) {
-        if (latestClaimedCheckpoint == 0) {
-            // First claim must be at the first checkpoint period
-            return claimedCheckpointHeight == checkpointPeriod;
-        }
-        // Subsequent claims must be at the next checkpoint
-        return claimedCheckpointHeight == latestClaimedCheckpoint + checkpointPeriod;
+        return claimedCheckpointHeight > 0 && claimedCheckpointHeight % checkpointPeriod == 0;
     }
 
     /// @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract

test/ValidatorGater.t.sol

@@ -83,9 +83,10 @@ contract ValidatorGaterTest is Test {
         assertFalse(gater.isAllow(validator1, 101)); // Above range
     }
 
-    function testFailUnauthorizedApprove() public {
+    function testRevertWhenUnauthorizedApprove() public {
         // Non-owner should not be able to approve a validator
         vm.prank(validator2); // validator2 is not the owner
+        vm.expectRevert(abi.encodeWithSignature("OwnableUnauthorizedAccount(address)", validator2));
         gater.approve(validator1, 10, 100);
     }