Merge pull request #182 from keep-network/eligible-by-address

Restore reward eligibility by operator address

Author: dimpar

contracts/Rewards.sol

@@ -72,13 +72,13 @@ contract Rewards {
   }
 
   /// @notice Return whether the operator is eligible for rewards or not.
-  function isEligibleForRewards(uint32 operator) public view returns (bool) {
+  function isEligibleForRewards(uint32 operator) internal view returns (bool) {
     return operatorRewards[operator].ineligibleUntil == 0;
   }
 
   /// @notice Return the time the operator's reward eligibility can be restored.
   function rewardsEligibilityRestorableAt(uint32 operator)
-    public
+    internal
     view
     returns (uint256)
   {
@@ -87,10 +87,10 @@ contract Rewards {
     return (uint256(until) + ineligibleOffsetStart);
   }
 
-  /// @notice Return whether the operator is able
-  /// to restore their eligibility for rewards right away.
+  /// @notice Return whether the operator is able to restore their eligibility
+  ///         for rewards right away.
   function canRestoreRewardEligibility(uint32 operator)
-    public
+    internal
     view
     returns (bool)
   {

contracts/SortitionPool.sol

@@ -137,6 +137,8 @@ contract SortitionPool is SortitionTree, Rewards, Ownable, IReceiveApproval {
     }
   }
 
+  /// @notice Set the given operators as ineligible for rewards.
+  ///         The operators can restore their eligibility at the given time.
   function setRewardIneligibility(uint32[] calldata operators, uint256 until)
     public
     onlyOwner
@@ -145,12 +147,40 @@ contract SortitionPool is SortitionTree, Rewards, Ownable, IReceiveApproval {
     emit IneligibleForRewards(operators, until);
   }
 
+  /// @notice Restores reward eligibility for the operator.
   function restoreRewardEligibility(address operator) public {
     uint32 id = getOperatorID(operator);
     Rewards.restoreEligibility(id);
     emit RewardEligibilityRestored(operator, id);
   }
 
+  /// @notice Returns whether the operator is eligible for rewards or not.
+  function isEligibleForRewards(address operator) public view returns (bool) {
+    uint32 id = getOperatorID(operator);
+    return Rewards.isEligibleForRewards(id);
+  }
+
+  /// @notice Returns the time the operator's reward eligibility can be restored.
+  function rewardsEligibilityRestorableAt(address operator)
+    public
+    view
+    returns (uint256)
+  {
+    uint32 id = getOperatorID(operator);
+    return Rewards.rewardsEligibilityRestorableAt(id);
+  }
+
+  /// @notice Returns whether the operator is able to restore their eligibility
+  ///         for rewards right away.
+  function canRestoreRewardEligibility(address operator)
+    public
+    view
+    returns (bool)
+  {
+    uint32 id = getOperatorID(operator);
+    return Rewards.canRestoreRewardEligibility(id);
+  }
+
   /// @notice Returns the amount of rewards withdrawable for the given operator.
   function getAvailableRewards(address operator) public view returns (uint96) {
     uint32 id = getOperatorID(operator);

test/sortitionPoolTest.js

@@ -378,17 +378,36 @@ describe("SortitionPool", () => {
       expect(ineligibleReward).to.equal(200)
     })
 
-    it("sets operator ineligibility correctly", async () => {
+    it("sets and restores operator eligibility correctly", async () => {
       await token.connect(deployer).mint(deployer.address, 1000)
       await pool.connect(owner).insertOperator(alice.address, 10000)
       await pool.connect(owner).insertOperator(bob.address, 20000)
+
       const now = await helpers.time.lastBlockTime()
       const bobID = await pool.getOperatorID(bob.address)
+
       await pool.connect(owner).setRewardIneligibility([bobID], now + 100)
 
+      expect(await pool.isEligibleForRewards(bob.address)).to.be.false
+      expect(await pool.isEligibleForRewards(alice.address)).to.be.true
+
+      expect(await pool.canRestoreRewardEligibility(bob.address)).to.be.false
+      expect(await pool.rewardsEligibilityRestorableAt(bob.address)).to.equal(
+        now + 100,
+      )
+
       await expect(
         pool.restoreRewardEligibility(bob.address),
       ).to.be.revertedWith("Operator still ineligible")
+
+      // Ineligibility is set for a duration. Bob was ineligible for 100
+      // seconds, so we move forward 101 seconds to allow us to make him
+      // eligible again.
+      await helpers.time.increaseTime(101)
+
+      expect(await pool.canRestoreRewardEligibility(bob.address)).to.be.true
+      await pool.restoreRewardEligibility(bob.address)
+      expect(await pool.isEligibleForRewards(bob.address)).to.be.true
     })
 
     it("can set many operators ineligible", async () => {