@etherisc/gif-next 0.0.2-a105567-464 → 0.0.2-a221fa7-461

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);
     }