@etherisc/gif-next 0.0.2-e964d24-516 → 0.0.2-e987ccf-894

package/contracts/staking/IStakingService.sol

@@ -1,15 +1,84 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
+
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 
 import {Amount} from "../type/Amount.sol";
 import {IService} from "../shared/IService.sol";
+import {IStaking} from "./IStaking.sol";
 import {NftId} from "../type/NftId.sol";
+import {ObjectType} from "../type/ObjectType.sol";
 import {Seconds} from "../type/Seconds.sol";
 import {Timestamp} from "../type/Timestamp.sol";
+import {TokenHandler} from "../shared/TokenHandler.sol";
+import {UFixed} from "../type/UFixed.sol";
 
 
 interface IStakingService is IService
 {
+
+    event LogStakingServiceProtocolTargetRegistered(NftId protocolNftId);
+    event LogStakingServiceInstanceTargetRegistered(NftId instanceNftId, uint256 chainId);
+    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, 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);
+    error ErrorStakingServiceNotStaking(address stakingAddress);
+    error ErrorStakingServiceNotSupportingIStaking(address stakingAddress);
+
+    // create
+    error ErrorStakingServiceZeroTargetNftId();
+    error ErrorStakingServiceNotTargetNftId(NftId targetNftId);
+    error ErrorStakingServiceNotActiveTargetNftId(NftId targetNftId);
+    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(
+        NftId targetNftId,
+        Seconds initialLockingPeriod,
+        UFixed initialRewardRate
+    ) 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 (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
     /// permissionless function
@@ -22,8 +91,9 @@ interface IStakingService is IService
             NftId stakeNftId
         );
 
+
     /// @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,
@@ -31,72 +101,60 @@ interface IStakingService is IService
     )
         external;
 
-    /// @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 closes the specified stake
-    /// all related stakes and all accumulated reward DIP are transferred to the current stake holder
-    /// function restricted to the current stake owner
-    function close(
-        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
-    function reStake(
+    function restakeToNewTarget(
         NftId stakeNftId,
         NftId newTargetNftId
     )
         external
         returns (
-            NftId newStakeNftId,
-            Timestamp unlockedAt
+            NftId newStakeNftId
         );
 
-    /// @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 updates the reward balance of the stake using the current reward rate.
+    function updateRewards(
+        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 claims all available rewards.
+    function claimRewards(
+        NftId stakeNftId
     )
-        external
-        returns (Amount totalValueLocked);
+        external;
 
-    /// @dev sends total value locked data to the global staking contract.
-    /// this is done via CCIP (cross chain communication) 
-    function sendTotalValueLockedData(
-        NftId targetNftId,
-        address token
+
+    /// @dev unstakes all dips (stakes and rewards) of an existing stake.
+    /// function restricted to the current stake owner
+    function unstake(
+        NftId stakeNftId
     )
         external;
 
-    /// @dev receives total value locked data from a staking contract on a different chain.
+
+    /// @dev sets total value locked data for a target contract on a different chain.
     /// this is done via CCIP (cross chain communication) 
-    function receiveTotalValueLockedData(
+    function setTotalValueLocked(
         NftId targetNftId,
-        address token
+        address token,
+        Amount amount
     )
         external;
+
+    function getDipToken()
+        external
+        returns (IERC20Metadata dip);
+
+    function getTokenHandler()
+        external
+        returns (TokenHandler tokenHandler);
+
+    function getStaking()
+        external
+        returns (IStaking staking);
 }

package/contracts/staking/StakeManagerLib.sol

@@ -0,0 +1,206 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+import {Amount, AmountLib} from "../type/Amount.sol";
+import {Component} from "../shared/Component.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
+import {IRegistryService} from "../registry/IRegistryService.sol";
+import {IStaking} from "./IStaking.sol";
+import {Key32} from "../type/Key32.sol";
+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 stake(
+        IRegistry registry,
+        StakingReader stakingReader,
+        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
+        )
+    {
+        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 checkTarget(
+        StakingReader stakingReader,
+        NftId targetNftId
+    )
+        public
+        view
+        returns (Seconds lockingPeriod)
+    {
+        // target nft id must be registered
+        if (!stakingReader.isTarget(targetNftId)) {
+            revert IStaking.ErrorStakingNotTarget(targetNftId);
+        }
+
+        // only accept stakes for active targets
+        if (!stakingReader.isActive(targetNftId)) {
+            revert IStaking.ErrorStakingTargetNotActive(targetNftId);
+        }
+
+        lockingPeriod = stakingReader.getTargetInfo(targetNftId).lockingPeriod;
+    }
+
+
+    function checkDipAmount(
+        StakingReader stakingReader,
+        NftId targetNftId, 
+        Amount dipAmount
+    )
+        public 
+        pure 
+    {
+        // check stake amount > 0
+        if (dipAmount.eqz()) {
+            revert IStaking.ErrorStakingStakeAmountZero(targetNftId);
+        }
+
+        // TODO add check for target specific max dip amount (min stake + tvl * stake rate + buffer)
+    }
+
+    function calculateRewardIncrease(
+        StakingReader stakingReader,
+        NftId stakeNftId,
+        UFixed rewardRate
+    )
+        public
+        view
+        returns (
+            Amount rewardIncreaseAmount,
+            Amount totalDipAmount
+        )
+    {
+        (
+            Amount stakeAmount,
+            Amount rewardAmount,
+            Timestamp lastUpdatedAt
+        ) = stakingReader.getStakeBalances(stakeNftId);
+
+        Seconds duration = SecondsLib.toSeconds(
+            block.timestamp - lastUpdatedAt.toInt());
+        
+        rewardIncreaseAmount = calculateRewardAmount(
+            rewardRate,
+            duration,
+            stakeAmount);
+
+        totalDipAmount = stakeAmount + rewardAmount + rewardIncreaseAmount;
+    }
+
+
+    function calculateRewardAmount(
+        UFixed rewardRate,
+        Seconds duration, 
+        Amount stakeAmount
+    )
+        public 
+        pure 
+        returns(
+            Amount rewardAmount
+        )
+    {
+        UFixed rewardRateFraction = getYearFraction(duration) * rewardRate;
+        rewardAmount = stakeAmount.multiplyWith(rewardRateFraction);
+    }
+
+
+    function getYearFraction(Seconds duration) public pure returns (UFixed yearFraction) {
+        return UFixedLib.toUFixed(duration.toInt()) / UFixedLib.toUFixed(SecondsLib.oneYear().toInt());
+    }
+
+}