@etherisc/gif-next 0.0.2-676522f-203 → 0.0.2-683d8b2-607

package/contracts/staking/IStakingService.sol

@@ -22,9 +22,15 @@ interface IStakingService is IService
     event LogStakingServiceLockingPeriodSet(NftId targetNftId, Seconds oldLockingDuration, Seconds lockingDuration);
     event LogStakingServiceRewardRateSet(NftId targetNftId, UFixed oldRewardRate, UFixed rewardRate);
 
+    event LogStakingServiceRewardReservesIncreased(NftId targetNftId, address rewardProvider, Amount dipAmount, Amount newBalance);
+    event LogStakingServiceRewardReservesDecreased(NftId targetNftId, address targetOwner, Amount dipAmount, Amount newBalance);
+
     event LogStakingServiceStakeCreated(NftId stakeNftId, NftId targetNftId, address owner, Amount stakedAmount);
-    event LogStakingServiceStakeIncreased(NftId stakeNftId, address owner, Amount stakedAmount);
+    event LogStakingServiceStakeIncreased(NftId stakeNftId, address owner, Amount stakedAmount, Amount stakeBalance);
+    event LogStakingServiceUnstaked(NftId stakeNftId, address stakeOwner, Amount totalAmount);
+
     event LogStakingServiceRewardsUpdated(NftId stakeNftId);
+    event LogStakingServiceRewardsClaimed(NftId stakeNftId, address stakeOwner, Amount rewardsClaimedAmount);
 
     // modifiers
     error ErrorStakingServiceNotNftOwner(NftId nftId, address expectedOwner, address owner);
@@ -38,6 +44,13 @@ interface IStakingService is IService
     error ErrorStakingServiceDipBalanceInsufficient(NftId targetNftId, uint256 amount, uint256 balance);
     error ErrorStakingServiceDipAllowanceInsufficient(NftId targetNftId, address tokenHandler, uint256 amount, uint256 allowance);
 
+    /// @dev Set the protocol reward rate stake locking period to the specified duration.
+    /// Permissioned: only staking owner
+    // TODO implement
+    // function setProtocolRewardRate(UFixed rewardRate) external;
+    // function setProtocolLockingPeriod(Seconds lockingPeriod) external;
+    // TODO also make sure that protocol rewards can be refilled and withdrawn
+
     /// @dev creates/registers an on-chain instance staking target.
     /// function granted to instance service
     function createInstanceTarget(
@@ -46,13 +59,25 @@ interface IStakingService is IService
         UFixed initialRewardRate
     ) external;
 
-    /// @dev set the stake locking period to the specified duration.
-    /// permissioned: only the owner of the specified target may set the locking period
-    function setLockingPeriod(NftId targetNftId, Seconds lockingPeriod) external;
+    /// @dev Set the instance stake locking period to the specified duration.
+    /// Permissioned: Only owner of the specified target.
+    function setInstanceLockingPeriod(NftId instanceNftId, Seconds lockingPeriod) external;
+
+    /// @dev Set the instance reward rate to the specified value.
+    /// Permissioned: Only owner of the specified target.
+    function setInstanceRewardRate(NftId instanceNftId, UFixed rewardRate) external;
+
+    /// @dev (Re)fills the staking reward reserves for the specified target using the dips provided by the reward provider.
+    /// unpermissioned: anybody may fill up staking reward reserves
+    function refillInstanceRewardReserves(NftId instanceNftId, address rewardProvider, Amount dipAmount) external returns (Amount newBalance);
 
-    /// @dev set the reward rate to the specified value
-    /// permissioned: only the owner of the specified target may set the locking period
-    function setRewardRate(NftId targetNftId, UFixed rewardRate) external;
+    /// @dev (Re)fills the staking reward reserves for the specified target using the dips provided by the sender
+    /// unpermissioned: anybody may fill up staking reward reserves
+    function refillRewardReservesBySender(NftId targetNftId, Amount dipAmount) external returns (Amount newBalance);
+
+    /// @dev Defunds the staking reward reserves for the specified target
+    /// Permissioned: only the target owner may call this function
+    function withdrawInstanceRewardReserves(NftId instanceNftId, Amount dipAmount) external returns (Amount newBalance);
 
     /// @dev create a new stake with amount DIP to the specified target
     /// returns the id of the newly minted stake nft
@@ -68,7 +93,7 @@ interface IStakingService is IService
 
 
     /// @dev increase an existing stake by amount DIP
-    /// updates the staking reward amount
+    /// updates and restakes the staking reward amount
     /// function restricted to the current stake owner
     function stake(
         NftId stakeNftId,
@@ -77,15 +102,6 @@ interface IStakingService is IService
         external;
 
 
-    /// @dev re-stakes the current staked DIP as well as all accumulated rewards to the new stake target.
-    /// all related stakes and all accumulated reward DIP are transferred to the current stake holder
-    /// function restricted to the current stake owner
-    function restake(
-        NftId stakeNftId
-    )
-        external;
-
-
     /// @dev re-stakes the current staked DIP as well as all accumulated rewards to the new stake target.
     /// all related stakes and all accumulated reward DIP are transferred to the current stake holder
     /// function restricted to the current stake owner
@@ -99,15 +115,6 @@ interface IStakingService is IService
         );
 
 
-    /// @dev decrease an existing stake by amount DIP
-    /// updates the staking reward amount
-    /// function restricted to the current stake owner
-    function unstake(
-        NftId stakeNftId,
-        Amount amount
-    )
-        external;
-
     /// @dev updates the reward balance of the stake using the current reward rate.
     function updateRewards(
         NftId stakeNftId
@@ -115,28 +122,19 @@ interface IStakingService is IService
         external;
 
 
-    /// @dev increases the total value locked amount for the specified target by the provided token amount.
-    /// function is called when a new policy is collateralized
-    /// function restricted to the pool service
-    function increaseTotalValueLocked(
-        NftId targetNftId,
-        address token,
-        Amount amount
+    /// @dev claims all available rewards.
+    function claimRewards(
+        NftId stakeNftId
     )
-        external
-        returns (Amount totalValueLocked);
+        external;
 
 
-    /// @dev decreases the total value locked amount for the specified target by the provided token amount.
-    /// function is called when a new policy is closed or payouts are executed
-    /// function restricted to the pool service
-    function decreaseTotalValueLocked(
-        NftId targetNftId,
-        address token,
-        Amount amount
+    /// @dev unstakes all dips (stakes and rewards) of an existing stake.
+    /// function restricted to the current stake owner
+    function unstake(
+        NftId stakeNftId
     )
-        external
-        returns (Amount totalValueLocked);
+        external;
 
 
     /// @dev sets total value locked data for a target contract on a different chain.

package/contracts/staking/StakeManagerLib.sol

@@ -13,41 +13,115 @@ import {NftId} from "../type/NftId.sol";
 import {ObjectType, INSTANCE, PROTOCOL, TARGET} from "../type/ObjectType.sol";
 import {Seconds, SecondsLib} from "../type/Seconds.sol";
 import {StakingReader} from "./StakingReader.sol";
+import {StakingStore} from "./StakingStore.sol";
 import {Timestamp, TimestampLib} from "../type/Timestamp.sol";
 import {UFixed, UFixedLib} from "../type/UFixed.sol";
 
 
 library StakeManagerLib {
 
-    function checkActiveTarget(
+    function stake(
+        IRegistry registry,
         StakingReader stakingReader,
-        NftId targetNftId
+        StakingStore stakingStore,
+        NftId stakeNftId,
+        Amount stakeAmount
+    )
+        external
+        returns (Amount stakeBalance)
+    {
+        // check that target is active for staking
+        (
+            UFixed rewardRate,
+            Seconds lockingPeriod
+        ) = checkStakeParameters(
+            stakingReader, 
+            stakeNftId);        
+
+        // calculate new rewards (if any)
+        (
+            Amount rewardIncrementAmount, 
+            Amount currentTotalDipAmount
+        ) = calculateRewardIncrease(
+            stakingReader, 
+            stakeNftId,
+            rewardRate);
+
+        stakeBalance = currentTotalDipAmount + stakeAmount;
+
+        // TODO check that additional dip, rewards and rewards increment 
+        // are still ok with max target staking amount
+        NftId targetNftId = registry.getObjectInfo(stakeNftId).parentNftId;
+
+        stakingStore.restakeRewards(
+            stakeNftId, 
+            targetNftId, 
+            rewardIncrementAmount);
+
+        stakingStore.increaseStake(
+            stakeNftId, 
+            targetNftId, 
+            stakeAmount);
+
+        // update locked until with target locking period
+        stakingStore.update(
+            stakeNftId, 
+            IStaking.StakeInfo({
+                lockedUntil: TimestampLib.blockTimestamp().addSeconds(
+                    lockingPeriod)}));
+
+    }
+
+    function checkCreateParameters(
+        StakingReader stakingReader,
+        NftId targetNftId, 
+        Amount dipAmount
+    )
+        external
+        view
+        returns (
+            Timestamp lockedUntil
+        )
+    {
+        Seconds lockingPeriod = checkTarget(stakingReader, targetNftId);
+        checkDipAmount(stakingReader, targetNftId, dipAmount);
+
+        Timestamp currentTime = TimestampLib.blockTimestamp();
+        lockedUntil = currentTime.addSeconds(lockingPeriod);
+    }
+
+
+    function checkStakeParameters(
+        StakingReader stakingReader,
+        NftId stakeNftId
     )
         public
         view
+        returns (
+            UFixed rewardRate,
+            Seconds lockingPeriod
+        )
     {
-        // target nft id must be registered
-        if (!stakingReader.isTarget(targetNftId)) {
-            revert IStaking.ErrorStakingNotTarget(targetNftId);
-        }
+        NftId targetNftId = stakingReader.getTargetNftId(stakeNftId);
 
         // only accept stakes for active targets
         if (!stakingReader.isActive(targetNftId)) {
             revert IStaking.ErrorStakingTargetNotActive(targetNftId);
         }
+
+        IStaking.TargetInfo memory info = stakingReader.getTargetInfo(targetNftId);
+        rewardRate = info.rewardRate;
+        lockingPeriod = info.lockingPeriod;
     }
 
 
-    function checkStakeParameters(
+    function checkTarget(
         StakingReader stakingReader,
-        NftId targetNftId, 
-        Amount dipAmount
+        NftId targetNftId
     )
-        external
+        public
         view
-        returns (
-            Timestamp lockedUntil
-        )
+        returns (Seconds lockingPeriod)
     {
         // target nft id must be registered
         if (!stakingReader.isTarget(targetNftId)) {
@@ -59,15 +133,12 @@ library StakeManagerLib {
             revert IStaking.ErrorStakingTargetNotActive(targetNftId);
         }
 
-        checkDipAmount(targetNftId, dipAmount);
-
-        Timestamp currentTime = TimestampLib.blockTimestamp();
-        lockedUntil = currentTime.addSeconds(
-            stakingReader.getTargetInfo(targetNftId).lockingPeriod);
+        lockingPeriod = stakingReader.getTargetInfo(targetNftId).lockingPeriod;
     }
 
 
     function checkDipAmount(
+        StakingReader stakingReader,
         NftId targetNftId, 
         Amount dipAmount
     )
@@ -109,17 +180,21 @@ library StakeManagerLib {
 
     function calculateRewardIncrease(
         StakingReader stakingReader,
-        NftId stakeNftId
+        NftId stakeNftId,
+        UFixed rewardRate
     )
         public
         view
-        returns (Amount rewardIncreaseAmount)
+        returns (
+            Amount rewardIncreaseAmount,
+            Amount totalDipAmount
+        )
     {
         (
-            UFixed rewardRate,
             Amount stakeAmount,
+            Amount rewardAmount,
             Timestamp lastUpdatedAt
-        ) = stakingReader.getRewardCalculationInput(stakeNftId);
+        ) = stakingReader.getStakeBalances(stakeNftId);
 
         Seconds duration = SecondsLib.toSeconds(
             block.timestamp - lastUpdatedAt.toInt());
@@ -128,6 +203,8 @@ library StakeManagerLib {
             rewardRate,
             duration,
             stakeAmount);
+
+        totalDipAmount = stakeAmount + rewardAmount + rewardIncreaseAmount;
     }
 
 
@@ -142,10 +219,8 @@ library StakeManagerLib {
             Amount rewardAmount
         )
     {
-        UFixed yearFraction = getYearFraction(duration);
-        UFixed rewardRateFraction = yearFraction * rewardRate;
-        UFixed amountUFixed = rewardRateFraction * stakeAmount.toUFixed();
-        rewardAmount = AmountLib.toAmount(amountUFixed.toInt());
+        UFixed rewardRateFraction = getYearFraction(duration) * rewardRate;
+        rewardAmount = stakeAmount.multiplyWith(rewardRateFraction);
     }