feat(Rewards): give incentive to batch submitter (#41)

Author: Alex Sedighi

src/Rewards.sol

@@ -94,6 +94,12 @@ contract Rewards is AccessControl, EIP712 {
      * @dev The sequence number of the batch reward.
      */
     uint256 public batchSequence;
+    /**
+     * @dev Determines the amount of rewards to be minted for the submitter of batch as a percentage of total rewards in that batch.
+     * This value indicates the cost overhead of minting rewards that the network is happy to take. Though it is set to 2% by default,
+     * the governance can change it to ensure the network is sustainable.
+     */
+    uint256 public batchSubmitterRewardPercentage;
 
     /**
      * @dev Error when the reward quota is exceeded.
@@ -124,6 +130,10 @@ contract Rewards is AccessControl, EIP712 {
      * The recipient and amounts arrays must have the same length.
      */
     error InvalidBatchStructure();
+    /**
+     * @dev Error thrown when the value is out of range. For example for Percentage values should be less than 100.
+     */
+    error OutOfRangeValue();
 
     /**
      * @dev Event emitted when the reward quota is set.
@@ -147,9 +157,13 @@ contract Rewards is AccessControl, EIP712 {
      * @param initialPeriod Initial reward period.
      * @param oracleAddress Address of the authorized oracle.
      */
-    constructor(NODL token, uint256 initialQuota, uint256 initialPeriod, address oracleAddress)
-        EIP712(SIGNING_DOMAIN, SIGNATURE_VERSION)
-    {
+    constructor(
+        NODL token,
+        uint256 initialQuota,
+        uint256 initialPeriod,
+        address oracleAddress,
+        uint256 rewardPercentage
+    ) EIP712(SIGNING_DOMAIN, SIGNATURE_VERSION) {
         // This is to avoid the ongoinb overhead of safe math operations
         if (initialPeriod == 0) {
             revert ZeroPeriod();
@@ -159,13 +173,16 @@ contract Rewards is AccessControl, EIP712 {
             revert TooLongPeriod();
         }
 
+        _mustBeLessThan100(batchSubmitterRewardPercentage);
+
         _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
 
         nodl = token;
         quota = initialQuota;
         period = initialPeriod;
         quotaRenewalTimestamp = block.timestamp + period;
         authorizedOracle = oracleAddress;
+        batchSubmitterRewardPercentage = rewardPercentage;
     }
 
     /**
@@ -208,19 +225,36 @@ contract Rewards is AccessControl, EIP712 {
         _mustBeFromAuthorizedOracle(digestBatchReward(batch), signature);
 
         _checkedUpdateQuota();
+
         uint256 batchSum = _batchSum(batch);
-        _checkedUpdateClaimed(batchSum);
+        uint256 submitterRewardAmount = (batchSum * batchSubmitterRewardPercentage) / 100;
+
+        _checkedUpdateClaimed(batchSum + submitterRewardAmount);
 
         // Safe to increment the sequence after checking this is the expected number (no overflow for the age of universe even with 1000 reward claims per second)
         batchSequence = batch.sequence + 1;
 
         for (uint256 i = 0; i < batch.recipients.length; i++) {
             nodl.mint(batch.recipients[i], batch.amounts[i]);
         }
+        nodl.mint(msg.sender, submitterRewardAmount);
 
         emit BatchMinted(batchSum, claimed);
     }
 
+    /**
+     * @dev Sets the reward percentage for the batch submitter.
+     * @param newPercentage The new reward percentage to be set.
+     * Requirements:
+     * - Caller must have the DEFAULT_ADMIN_ROLE.
+     * - The new reward percentage must be less than 100.
+     */
+    function setBatchSubmitterRewardPercentage(uint256 newPercentage) external {
+        _checkRole(DEFAULT_ADMIN_ROLE);
+        _mustBeLessThan100(newPercentage);
+        batchSubmitterRewardPercentage = newPercentage;
+    }
+
     /**
      * @dev Internal function to update the rewards quota if the current block timestamp is greater than or equal to the quota renewal timestamp.
      * @notice This function resets the rewards claimed to 0 and updates the quota renewal timestamp based on the reward period.
@@ -251,6 +285,17 @@ contract Rewards is AccessControl, EIP712 {
         claimed = newClaimed;
     }
 
+    /**
+     * @dev Checks if the given percentage value is less than or equal to 100.
+     * @param percent The percentage value to check.
+     * @dev Throws an exception if the value is greater than 100.
+     */
+    function _mustBeLessThan100(uint256 percent) internal pure {
+        if (percent > 100) {
+            revert OutOfRangeValue();
+        }
+    }
+
     /**
      * @dev Internal check to ensure the `sequence` value is expected for `receipent`.
      * @param receipent The address of the receipent to check.

test/Rewards.t.sol

@@ -24,7 +24,7 @@ contract RewardsTest is Test {
         address oracle = vm.addr(oraclePrivateKey);
 
         nodlToken = new NODL();
-        rewards = new Rewards(nodlToken, 1000, RENEWAL_PERIOD, oracle);
+        rewards = new Rewards(nodlToken, 1000, RENEWAL_PERIOD, oracle, 2);
         // Grant MINTER_ROLE to the Rewards contract
         nodlToken.grantRole(nodlToken.MINTER_ROLE(), address(rewards));
     }
@@ -98,23 +98,27 @@ contract RewardsTest is Test {
     }
 
     function test_mintBatchReward() public {
+        address submitter = address(44);
         address[] memory recipients = new address[](2);
         uint256[] memory amounts = new uint256[](2);
 
         recipients[0] = address(11);
         recipients[1] = address(22);
         amounts[0] = 100;
         amounts[1] = 200;
+        uint256 submitterReward = (amounts[0] + amounts[1]) * rewards.batchSubmitterRewardPercentage() / 100;
 
         Rewards.BatchReward memory rewardsBatch = Rewards.BatchReward(recipients, amounts, 0);
 
         bytes memory signature = createBatchSignature(rewardsBatch, oraclePrivateKey);
 
+        vm.prank(submitter);
         rewards.mintBatchReward(rewardsBatch, signature);
 
-        assertEq(nodlToken.balanceOf(recipients[0]), 100);
-        assertEq(nodlToken.balanceOf(recipients[1]), 200);
-        assertEq(rewards.claimed(), 300);
+        assertEq(nodlToken.balanceOf(recipients[0]), amounts[0]);
+        assertEq(nodlToken.balanceOf(recipients[1]), amounts[1]);
+        assertEq(nodlToken.balanceOf(submitter), submitterReward);
+        assertEq(rewards.claimed(), amounts[0] + amounts[1] + submitterReward);
         assertEq(rewards.sequences(recipients[0]), 0);
         assertEq(rewards.sequences(recipients[1]), 0);
         assertEq(rewards.batchSequence(), 1);
@@ -315,7 +319,7 @@ contract RewardsTest is Test {
         Rewards.BatchReward memory rewardsBatch = Rewards.BatchReward(recipients, amounts, 0);
         bytes memory batchSignature = createBatchSignature(rewardsBatch, oraclePrivateKey);
         rewards.mintBatchReward(rewardsBatch, batchSignature);
-        assertEq(rewards.claimed(), 300);
+        assertEq(rewards.claimed(), 300 + 300 * rewards.batchSubmitterRewardPercentage() / 100);
 
         assertEq(rewards.quotaRenewalTimestamp(), sixthRenewal);
     }
@@ -354,6 +358,108 @@ contract RewardsTest is Test {
         assertEq(rewards.claimed(), 30);
     }
 
+    function test_setBatchSubmitterRewardPercentage() public {
+        address alice = address(2);
+        rewards.grantRole(rewards.DEFAULT_ADMIN_ROLE(), alice);
+
+        assertEq(rewards.batchSubmitterRewardPercentage(), 2);
+
+        vm.prank(alice);
+        rewards.setBatchSubmitterRewardPercentage(10);
+
+        assertEq(rewards.batchSubmitterRewardPercentage(), 10);
+    }
+
+    function test_setBatchSubmitterRewardPercentageUnauthorized() public {
+        address bob = address(3);
+        vm.expectRevert_AccessControlUnauthorizedAccount(bob, rewards.DEFAULT_ADMIN_ROLE());
+        vm.prank(bob);
+        rewards.setBatchSubmitterRewardPercentage(10);
+    }
+
+    function test_setBatchSubmitterRewardPercentageOutOfRange() public {
+        address alice = address(2);
+        rewards.grantRole(rewards.DEFAULT_ADMIN_ROLE(), alice);
+
+        vm.expectRevert(Rewards.OutOfRangeValue.selector);
+        vm.prank(alice);
+        rewards.setBatchSubmitterRewardPercentage(101);
+    }
+
+    function test_changingSubmitterRewardPercentageIsEffective() public {
+        address alice = address(2);
+        rewards.grantRole(rewards.DEFAULT_ADMIN_ROLE(), alice);
+
+        assertEq(rewards.batchSubmitterRewardPercentage(), 2);
+
+        vm.prank(alice);
+        rewards.setBatchSubmitterRewardPercentage(100);
+
+        assertEq(rewards.batchSubmitterRewardPercentage(), 100);
+
+        address[] memory recipients = new address[](2);
+        uint256[] memory amounts = new uint256[](2);
+        recipients[0] = address(11);
+        recipients[1] = address(22);
+        amounts[0] = 100;
+        amounts[1] = 200;
+        Rewards.BatchReward memory rewardsBatch = Rewards.BatchReward(recipients, amounts, 0);
+        bytes memory batchSignature = createBatchSignature(rewardsBatch, oraclePrivateKey);
+        vm.prank(alice);
+        rewards.mintBatchReward(rewardsBatch, batchSignature);
+
+        assertEq(rewards.claimed(), 2 * 300); // expected value for 100% submitter reward
+        assertEq(nodlToken.balanceOf(alice), 300);
+    }
+
+    function test_mintBatchRewardOverflowsOnBatchSum() public {
+        address[] memory recipients = new address[](2);
+        uint256[] memory amounts = new uint256[](2);
+
+        recipients[0] = address(11);
+        recipients[1] = address(22);
+        amounts[0] = type(uint256).max;
+        amounts[1] = 1;
+
+        Rewards.BatchReward memory rewardsBatch = Rewards.BatchReward(recipients, amounts, 0);
+
+        bytes memory signature = createBatchSignature(rewardsBatch, oraclePrivateKey);
+        vm.expectRevert(stdError.arithmeticError);
+        rewards.mintBatchReward(rewardsBatch, signature);
+    }
+
+    function test_mintBatchRewardOverflowsOnSubmitterReward() public {
+        address alice = address(2);
+        rewards.grantRole(rewards.DEFAULT_ADMIN_ROLE(), alice);
+
+        // Ensure the quota is high enough
+        vm.prank(alice);
+        rewards.setQuota(type(uint256).max);
+
+        // Check initial submitter reward percentage
+        assertEq(rewards.batchSubmitterRewardPercentage(), 2);
+
+        address[] memory recipients = new address[](1);
+        uint256[] memory amounts = new uint256[](1);
+
+        recipients[0] = address(11);
+        // This amount, even though high, should not cause an overflow
+        amounts[0] = type(uint256).max / (2 * rewards.batchSubmitterRewardPercentage());
+
+        Rewards.BatchReward memory rewardsBatch = Rewards.BatchReward(recipients, amounts, 0);
+        bytes memory signature = createBatchSignature(rewardsBatch, oraclePrivateKey);
+        rewards.mintBatchReward(rewardsBatch, signature);
+
+        vm.prank(alice);
+        // Same batch sum should now cause an overflow in the submitter reward calculation
+        rewards.setBatchSubmitterRewardPercentage(100);
+
+        Rewards.BatchReward memory rewardsBatch2 = Rewards.BatchReward(recipients, amounts, 1);
+        bytes memory signature2 = createBatchSignature(rewardsBatch2, oraclePrivateKey);
+        vm.expectRevert(stdError.arithmeticError);
+        rewards.mintBatchReward(rewardsBatch2, signature2);
+    }
+
     function createSignature(Rewards.Reward memory reward, uint256 privateKey) internal view returns (bytes memory) {
         bytes32 digest = rewards.digestReward(reward);
         (uint8 v, bytes32 r, bytes32 s) = vm.sign(privateKey, digest);