feat: update implementation with remaining time and amount

contracts/implementations/ChildGauge.vy

@@ -61,8 +61,8 @@ event NewReward:
 struct Reward:
     token: ERC20
     distributor: address
-    period_finish: uint256
-    rate: uint256
+    remaining_time: uint256
+    remaining_amount: uint256
     last_update: uint256
     integral: uint256
     precision: uint256
@@ -234,12 +234,14 @@ def _checkpoint_rewards(_user: address, _total_supply: uint256, _claim: bool, _r
         data: Reward = self.reward_data[i]
 
         integral: uint256 = data.integral
-        last_update: uint256 = min(block.timestamp, data.period_finish)
-        duration: uint256 = last_update - data.last_update
+        duration: uint256 = min(block.timestamp - data.last_update, data.remaining_time)
         if duration != 0:
-            self.reward_data[i].last_update = last_update
+            self.reward_data[i].last_update = data.last_update + duration
             if _total_supply != 0:
-                integral += duration * data.rate * 10**18 / _total_supply
+                amount_for_duration: uint256 = (data.remaining_amount * data.precision) * duration / data.remaining_time
+                integral += amount_for_duration * 10**18 / _total_supply
+                self.reward_data[i].remaining_time = data.remaining_time - duration
+                self.reward_data[i].remaining_amount = data.remaining_amount - amount_for_duration
                 self.reward_data[i].integral = integral
 
         if _user != empty(address):
@@ -256,7 +258,8 @@ def _checkpoint_rewards(_user: address, _total_supply: uint256, _claim: bool, _r
                 total_claimed: uint256 = claim_data % 2**128
                 if _claim:
                     assert data.token.transfer(receiver, total_claimable / data.precision, default_return_value=True)
-                    self.claim_data[_user][i] = total_claimed + total_claimable
+                    self.claim_data[_user][i] = total_claimed + total_claimable / data.precision +\
+                        shift(total_claimable % data.precision, 128)
                 elif new_claimable > 0:
                     self.claim_data[_user][i] = total_claimed + shift(total_claimable, 128)
 
@@ -541,8 +544,10 @@ def _claimable_reward(user: address, reward_id: uint256, reward_data: Reward) ->
     integral: uint256 = reward_data.integral
     total_supply: uint256 = self.totalSupply
     if total_supply != 0:
-        duration: uint256 = min(block.timestamp, reward_data.period_finish) - reward_data.last_update
-        integral += (duration * reward_data.rate * 10**18 / total_supply)
+        duration: uint256 = min(block.timestamp - reward_data.last_update, reward_data.remaining_time)
+        amount_for_duration: uint256 = (reward_data.remaining_amount * reward_data.precision) *\
+            duration / reward_data.remaining_time
+        integral += (amount_for_duration * 10**18 / total_supply)
 
     integral_for: uint256 = self.reward_integral_for[reward_id][user]
     new_claimable: uint256 = self.balanceOf[user] * (integral - integral_for) / 10**18
@@ -621,12 +626,13 @@ def add_reward(_reward_token: ERC20, _distributor: address, _precision: uint256=
     precision: uint256 = _precision
     if precision == 0:
         precision = 10 ** (18 - ERC20Extended(_reward_token.address).decimals())
+    assert precision <= 10 ** 18, "Precision too big"
     self.reward_data.append(
         Reward({
             token: _reward_token,
             distributor: _distributor,
-            period_finish: 0,
-            rate: 0,
+            remaining_time: 0,
+            remaining_amount: 0,
             last_update: 0,
             integral: 0,
             precision: precision,
@@ -649,44 +655,65 @@ def set_reward_distributor(_reward_id: uint256, _distributor: address):
     self.reward_data[_reward_id].distributor = _distributor
 
 
+@internal
+@pure
+def _check_reward_boundaries(reward_data: Reward):
+    """
+    @notice Check that reward parameters will not overflow
+    """
+    assert reward_data.remaining_time * reward_data.remaining_amount * reward_data.precision <= max_value(uint256)
+    assert reward_data.remaining_amount * reward_data.precision * 10 ** 18 <= max_value(uint256)
+
+
 @external
-@nonreentrant("lock")
-def deposit_reward_token(_reward_id: uint256, _amount: uint256, _new_duration: uint256=0, _new_period_finish: uint256=0):
+def deposit_reward(_reward_id: uint256, _amount: uint256):
     """
-    @notice Deposit tokens for rewards.
-    @param _reward_id ID of reward to deposit to
-    @param _amount Amount of reward token to deposit
-    @param _new_duration Optional. Minimum reward duration period
-    @param _new_period_finish Optional. Timestamp for new period finish
+    @notice Deposit reward tokens for distribution
+    @param _reward_id ID of reward (index in reward_data)
+    @param _amount Amount to deposit for rewards
     """
     reward_data: Reward = self.reward_data[_reward_id]
-    assert msg.sender == reward_data.distributor
 
     self._checkpoint_rewards(empty(address), self.totalSupply, False, empty(address))
 
     assert reward_data.token.transferFrom(msg.sender, self, _amount, default_return_value=True)
+    reward_data.remaining_amount += _amount
+    self._check_reward_boundaries(reward_data)
+    self.reward_data[_reward_id].remaining_time = reward_data.remaining_amount
+
+
+@external
+def recover_remaining_reward(_reward_id: uint256, _receiver: address=msg.sender):
+    """
+    @notice Recover reward tokens. Only when remaining time = 0
+    @param _reward_id ID of reward (index in reward_data)
+    @param _receiver Receiver of recovered tokens (distributor by default)
+    """
+    reward_data: Reward = self.reward_data[_reward_id]
+    assert msg.sender == reward_data.distributor
+    assert reward_data.remaining_time == 0, "Distribution in progress"
+
+    self._checkpoint_rewards(empty(address), self.totalSupply, False, empty(address))
+
+    self.reward_data[_reward_id].remaining_amount = 0
+    assert reward_data.token.transfer(_receiver, reward_data.remaining_amount, default_return_value=True)
+
+
+@external
+def set_reward_duration(_reward_id: uint256, _duration: uint256):
+    """
+    @notice Set duration for reward distribution. Function works as a trigger to start reward distribution
+    @param _reward_id ID of reward (index in reward_data)
+    @param _duration Time for reward distribution in seconds
+    """
+    reward_data: Reward = self.reward_data[_reward_id]
+    assert msg.sender == reward_data.distributor
+
+    self._checkpoint_rewards(empty(address), self.totalSupply, False, empty(address))
 
-    new_period_finish: uint256 = block.timestamp + WEEK  # default
-    if _new_period_finish != 0:
-        new_period_finish = _new_period_finish
-    elif _new_duration != 0:
-        new_period_finish = block.timestamp + _new_duration
-    elif reward_data.period_finish >= block.timestamp + WEEK:  # Backward-compatible behaviour
-        new_period_finish = reward_data.period_finish
-    duration: uint256 = new_period_finish - block.timestamp
-
-    amount: uint256 = _amount * reward_data.precision
-    if block.timestamp < reward_data.period_finish:  # add leftover
-        amount += (reward_data.period_finish - block.timestamp) * reward_data.rate
-
-    new_rate: uint256 = amount / duration
-    if block.timestamp + WEEK < reward_data.period_finish:  # allow radical changes only last week
-        assert new_period_finish >= reward_data.period_finish, "Period rug too early"
-        assert new_rate >= reward_data.rate, "Rate rug too early"
-
-    self.reward_data[_reward_id].rate = new_rate
-    self.reward_data[_reward_id].last_update = block.timestamp  # in case last_update < block.timestamp
-    self.reward_data[_reward_id].period_finish = new_period_finish
+    reward_data.remaining_time = _duration
+    self._check_reward_boundaries(reward_data)
+    self.reward_data[_reward_id].remaining_time = _duration
 
 
 @external