@etherisc/gif-next 0.0.2-7f39e38-904 → 0.0.2-804cdbf-724

package/contracts/staking/IStaking.sol

@@ -5,7 +5,6 @@ import {Amount} from "../type/Amount.sol";
 import {IComponent} from "../shared/IComponent.sol";
 import {IVersionable} from "../shared/IVersionable.sol";
 import {NftId} from "../type/NftId.sol";
-import {NftIdSetManager} from "../shared/NftIdSetManager.sol";
 import {ObjectType} from "../type/ObjectType.sol";
 import {Seconds} from "../type/Seconds.sol";
 import {StakingReader} from "./StakingReader.sol";
@@ -17,6 +16,8 @@ interface IStaking is
     IComponent,
     IVersionable
 {
+    // staking rate
+    event LogStakingStakingRateSet(uint256 chainId, address token, UFixed oldStakingRate, UFixed newStakingRate);
 
     // target parameters
     event LogStakingLockingPeriodSet(NftId targetNftId, Seconds oldLockingPeriod, Seconds lockingPeriod);
@@ -29,6 +30,9 @@ interface IStaking is
     error ErrorStakingNotStakingOwner();
     error ErrorStakingNotNftOwner(NftId nftId);
 
+    // staking rate
+    error ErrorStakingTokenNotRegistered(uint256 chainId, address token);
+
     // check dip balance and allowance
     error ErrorStakingDipBalanceInsufficient(address owner, uint256 amount, uint256 dipBalance);
     error ErrorStakingDipAllowanceInsufficient(address owner, address tokenHandler, uint256 amount, uint256 dipAllowance);
@@ -59,7 +63,10 @@ interface IStaking is
         UFixed rewardRate;
     }
 
-    // rate management 
+    // staking rate management 
+
+    /// @dev sets the rate that converts 1 token of total value locked into the
+    /// the required staked dip amount to back up the locked token value
     function setStakingRate(uint256 chainId, address token, UFixed stakingRate) external;
 
 
@@ -73,31 +80,53 @@ interface IStaking is
         UFixed initialRewardRate
     ) external;
 
+
     /// @dev set the stake locking period to the specified duration.
+    /// permissioned: only the staking service may call this function
     function setLockingPeriod(NftId targetNftId, Seconds lockingPeriod) external;
 
+    /// @dev update the target specific reward rate.
+    /// permissioned: only the staking service may call this function
     function setRewardRate(NftId targetNftId, UFixed rewardRate) external;
-    function refillRewardReserves(NftId targetNftId, Amount dipAmount) external;
-    function withdrawRewardReserves(NftId targetNftId, Amount dipAmount) external;
 
-    function increaseTvl(NftId targetNftId, address token, Amount amount) external;
-    function decreaseTvl(NftId targetNftId, address token, Amount amount) external;
+    /// @dev (re)fills the staking reward reserves for the specified target
+    /// unpermissioned: anybody may fill up staking reward reserves
+    function refillRewardReserves(NftId targetNftId, Amount dipAmount) external returns (Amount newBalance);
+
+    /// @dev defunds the staking reward reserves for the specified target
+    /// permissioned: only the staking service may call this function
+    function withdrawRewardReserves(NftId targetNftId, Amount dipAmount) external returns (Amount newBalance);
+
+
+    /// @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) external returns (Amount newBalance);
+
+
+    /// @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) external returns (Amount newBalance);
+
 
     function updateRemoteTvl(NftId targetNftId, address token, Amount amount) external;
 
     // staking functions
 
-    /// @dev register a new stake info object
+    /// @dev creat a new stake info object
     /// permissioned: only staking service may call this function.
-    function registerStake(NftId stakeNftId, NftId targetNftId, Amount dipAmount) external;
+    function createStake(NftId stakeNftId, NftId targetNftId, Amount dipAmount) external;
 
-    /// @dev increase the staked dip by dipAmount for the specified stake
-    function stake(NftId stakeNftId, Amount dipAmount) external;
+    /// @dev increase the staked dip by dipAmount for the specified stake.
+    /// staking rewards are updated and added to the staked dips as well.
+    /// the function returns the new total amount of staked dips.
+    function stake(NftId stakeNftId, Amount dipAmount) external returns (Amount stakeBalance);
 
     /// @dev restakes the dips to a new target.
     /// the sum of the staked dips and the accumulated rewards will be restaked.
     /// permissioned: only staking service may call this function.
-    function restake(NftId stakeNftId) external;
+    function restake(NftId stakeNftId, NftId newTargetNftId) external returns (NftId newStakeNftId);
 
     /// @dev retuns the specified amount of dips to the holder of the specified stake nft.
     /// if dipAmount is set to Amount.max() all staked dips and all rewards are transferred to 
@@ -135,18 +164,4 @@ interface IStaking is
 
     function getStakingStore() external view returns (StakingStore stakingStore);
     function getStakingReader() external view returns (StakingReader reader);
-
-    // function getStakeInfo(NftId stakeNftId) external view returns (StakeInfo memory stakeInfo);
-    // function getTargetInfo(NftId targetNftId) external view returns (TargetInfo memory targetInfo);
-
-    function getTvlAmount(NftId targetNftId, address token) external view returns (Amount tvlAmount);
-    function getStakedAmount(NftId targetNftId) external view returns (Amount stakeAmount);
-
-    function getStakingRate(uint256 chainId, address token) external view returns (UFixed stakingRate);
-
-    function calculateRewardIncrementAmount(
-        NftId targetNftId,
-        Timestamp rewardsLastUpdatedAt
-    ) external view returns (Amount rewardIncrementAmount);
-
 }

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