Merge pull request #584 from keep-network/rewards-cap

Cap the maximum reward per ECDSA keep operator per interval

Author: dimpar

solidity/contracts/ECDSARewards.sol

@@ -87,9 +87,25 @@ contract ECDSARewards is Rewards {
 
     uint256 internal constant minimumECDSAKeepsPerInterval = 1000;
 
-    BondedECDSAKeepFactory factory;
+    // The amount of tokens each individual beneficiary address
+    // can receive in a single interval is capped.
+    // TODO: set actual value
+    uint256 internal constant beneficiaryRewardCap = 400000 * 10**18;
+    // The total amount of rewards allocated to the given beneficiary address,
+    // in the given interval.
+    // `allocatedRewards[beneficiary][interval] -> amount`
+    mapping(address => mapping(uint256 => uint256)) internal allocatedRewards;
+    // The amount of interval rewards withdrawn to the given beneficiary.
+    mapping(address => mapping(uint256 => uint256)) internal withdrawnRewards;
 
-    constructor(address _token, address payable _factoryAddress)
+    BondedECDSAKeepFactory internal factory;
+    TokenStaking internal tokenStaking;
+
+    constructor(
+        address _token,
+        address payable _factoryAddress,
+        address _tokenStakingAddress
+    )
         public
         Rewards(
             _token,
@@ -100,6 +116,70 @@ contract ECDSARewards is Rewards {
         )
     {
         factory = BondedECDSAKeepFactory(_factoryAddress);
+        tokenStaking = TokenStaking(_tokenStakingAddress);
+    }
+
+    /// @notice Get the amount of rewards allocated
+    /// for the specified operator's beneficiary in the specified interval.
+    /// @param interval The interval
+    /// @param operator The operator
+    /// @return The amount allocated
+    function getAllocatedRewards(uint256 interval, address operator)
+        external
+        view
+        returns (uint256)
+    {
+        address beneficiary = tokenStaking.beneficiaryOf(operator);
+        return allocatedRewards[beneficiary][interval];
+    }
+
+    /// @notice Get the amount of rewards already withdrawn
+    /// for the specified operator's beneficiary in the specified interval.
+    /// @param interval The interval
+    /// @param operator The operator
+    /// @return The amount already withdrawn
+    function getWithdrawnRewards(uint256 interval, address operator)
+        external
+        view
+        returns (uint256)
+    {
+        address beneficiary = tokenStaking.beneficiaryOf(operator);
+        return withdrawnRewards[beneficiary][interval];
+    }
+
+    /// @notice Get the amount of rewards withdrawable
+    /// for the specified operator's beneficiary in the specified interval.
+    /// @param interval The interval
+    /// @param operator The operator
+    /// @return The amount withdrawable
+    function getWithdrawableRewards(uint256 interval, address operator)
+        external
+        view
+        returns (uint256)
+    {
+        address beneficiary = tokenStaking.beneficiaryOf(operator);
+        uint256 allocated = allocatedRewards[beneficiary][interval];
+        uint256 withdrawn = withdrawnRewards[beneficiary][interval];
+        return allocated.sub(withdrawn);
+    }
+
+    /// @notice Withdraw all available rewards for the given interval.
+    /// The rewards will be paid to the beneficiary of the specified operator.
+    /// @param interval The interval
+    /// @param operator The operator
+    function withdrawRewards(uint256 interval, address operator) external {
+        address beneficiary = tokenStaking.beneficiaryOf(operator);
+
+        uint256 allocated = allocatedRewards[beneficiary][interval];
+        uint256 alreadyWithdrawn = withdrawnRewards[beneficiary][interval];
+
+        require(allocated > alreadyWithdrawn, "No rewards to withdraw");
+
+        uint256 withdrawableRewards = allocated.sub(alreadyWithdrawn);
+
+        withdrawnRewards[beneficiary][interval] = allocated;
+
+        token.safeTransfer(beneficiary, withdrawableRewards);
     }
 
     /// @notice Stakers can receive KEEP rewards from multiple keeps of their choice
@@ -158,16 +238,43 @@ contract ECDSARewards is Rewards {
         return factory.getKeepOpenedTimestamp(toAddress(_keep)) != 0;
     }
 
+    /// @notice Get the members of the specified keep, and distribute the reward
+    /// amount between them. The reward isn't paid out immediately,
+    /// but is instead kept in the reward contract until each operator
+    /// individually requests to withdraw the rewards.
     function _distributeReward(bytes32 _keep, uint256 amount)
         internal
         isAddress(_keep)
     {
-        token.approve(toAddress(_keep), amount);
+        address[] memory members = BondedECDSAKeep(toAddress(_keep))
+            .getMembers();
+        uint256 interval = intervalOf(_getCreationTime(_keep));
+
+        uint256 memberCount = members.length;
+        uint256 dividend = amount.div(memberCount);
+        uint256 remainder = amount.mod(memberCount);
+
+        uint256[] memory allocations = new uint256[](memberCount);
 
-        BondedECDSAKeep(toAddress(_keep)).distributeERC20Reward(
-            address(token),
-            amount
-        );
+        for (uint256 i = 0; i < memberCount - 1; i++) {
+            allocations[i] = dividend;
+        }
+        allocations[memberCount - 1] = dividend.add(remainder);
+
+        for (uint256 i = 0; i < memberCount; i++) {
+            address beneficiary = tokenStaking.beneficiaryOf(members[i]);
+            uint256 addedAllocation = allocations[i];
+            uint256 prevAllocated = allocatedRewards[beneficiary][interval];
+            uint256 newAllocation = prevAllocated.add(addedAllocation);
+            if (newAllocation > beneficiaryRewardCap) {
+                uint256 deallocatedAmount = newAllocation.sub(
+                    beneficiaryRewardCap
+                );
+                newAllocation = beneficiaryRewardCap;
+                deallocate(deallocatedAmount);
+            }
+            allocatedRewards[beneficiary][interval] = newAllocation;
+        }
     }
 
     function toAddress(bytes32 keepBytes) internal pure returns (address) {