@etherisc/gif-next 0.0.2-7f05179-874 → 0.0.2-7f39e38-904

package/contracts/staking/IStakingService.sol

@@ -0,0 +1,162 @@
+// SPDX-License-Identifier: Apache-2.0
+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 LogStakingServiceStakeCreated(NftId stakeNftId, NftId targetNftId, address owner, Amount stakedAmount);
+    event LogStakingServiceStakeIncreased(NftId stakeNftId, address owner, Amount stakedAmount);
+    event LogStakingServiceRewardsUpdated(NftId stakeNftId);
+
+    // 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 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 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 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 create a new stake with amount DIP to the specified target
+    /// returns the id of the newly minted stake nft
+    /// permissionless function
+    function create(
+        NftId targetNftId,
+        Amount amount
+    )
+        external
+        returns (
+            NftId stakeNftId
+        );
+
+
+    /// @dev increase an existing stake by amount DIP
+    /// updates the staking reward amount
+    /// function restricted to the current stake owner
+    function stake(
+        NftId stakeNftId,
+        Amount amount
+    )
+        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
+    function restakeToNewTarget(
+        NftId stakeNftId,
+        NftId newTargetNftId
+    )
+        external
+        returns (
+            NftId newStakeNftId
+        );
+
+
+    /// @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
+    )
+        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
+    )
+        external
+        returns (Amount totalValueLocked);
+
+
+    /// @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 totalValueLocked);
+
+
+    /// @dev sets total value locked data for a target contract on a different chain.
+    /// this is done via CCIP (cross chain communication) 
+    function setTotalValueLocked(
+        NftId targetNftId,
+        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/IStakingStore.sol

@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {AccessManaged} from "@openzeppelin/contracts/access/manager/AccessManaged.sol";
+
+import {Amount, AmountLib} from "../type/Amount.sol";
+import {Blocknumber, BlocknumberLib} from "../type/Blocknumber.sol";
+import {ChainNft} from "../registry/ChainNft.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 {IVersionable} from "../shared/IVersionable.sol";
+import {Key32} from "../type/Key32.sol";
+import {KeyValueStore} from "../shared/KeyValueStore.sol";
+import {KEEP_STATE} from "../type/StateId.sol";
+import {LibNftIdSet} from "../type/NftIdSet.sol";
+import {NftId, NftIdLib} from "../type/NftId.sol";
+import {NftIdSetManager} from "../shared/NftIdSetManager.sol";
+import {ObjectType, INSTANCE, PROTOCOL, STAKE, STAKING, TARGET} from "../type/ObjectType.sol";
+import {Seconds, SecondsLib} from "../type/Seconds.sol";
+import {StakingReader} from "./StakingReader.sol";
+import {TargetManagerLib} from "./TargetManagerLib.sol";
+import {Timestamp, TimestampLib} from "../type/Timestamp.sol";
+import {TokenRegistry} from "../registry/TokenRegistry.sol";
+import {UFixed, UFixedLib} from "../type/UFixed.sol";
+import {Version, VersionLib} from "../type/Version.sol";
+import {Versionable} from "../shared/Versionable.sol";
+
+
+interface IStakingStore {
+
+    // event LogStakingStoreStakesIncreased(NftId nftId, Amount addedAmount, Amount newBalance, Blocknumber lastUpdatedIn);
+    // event LogStakingStoreStakesDecreased(NftId nftId, Amount addedAmount, Amount newBalance, Blocknumber lastUpdatedIn);
+
+    // event LogStakingStoreRewardsIncreased(NftId nftId, Amount addedAmount, Amount newBalance, Blocknumber lastUpdatedIn);
+    // event LogStakingStoreRewardsDecreased(NftId nftId, Amount addedAmount, Amount newBalance, Blocknumber lastUpdatedIn);
+
+    // event LogStakingStoreRewardsRestaked(NftId nftId, Amount amount, Amount rewardAmount, Amount rewardIncrementAmount, Amount newBalance, Blocknumber lastUpdatedIn);
+
+    // // creating and updating of balance
+    // error ErrorStakingStoreBalanceAlreadyInitialized(NftId nftId);
+    // error ErrorStakingStoreBalanceNotInitialized(NftId nftId);
+
+    //--- target specific functions ------------------------------------//
+
+    function createTarget(
+        NftId targetNftId,
+        IStaking.TargetInfo memory targetInfo
+    )
+        external;
+
+
+    function updateTarget(
+        NftId targetNftId, 
+        IStaking.TargetInfo memory targetInfo
+    )
+        external;
+
+    //--- stake specific functions -------------------------------------//
+
+    function create(
+        NftId stakeNftId, 
+        IStaking.StakeInfo memory stakeInfo,
+        Amount stakeAmount
+    )
+        external;
+
+    function update(
+        NftId stakeNftId, 
+        IStaking.StakeInfo memory stakeInfo
+    )
+        external;
+
+    //--- general functions --------------------------------------------//
+
+
+    function increaseBalance(NftId nftId, Amount amount, Amount rewardIncrementAmount)
+        external;
+
+
+    function restakeRewards(
+        NftId nftId, 
+        Amount rewardIncrementAmount
+    )
+        external;
+
+
+    function updateRewards(
+        NftId nftId, 
+        Amount rewardIncrementAmount
+    )
+        external;
+
+
+    function claimUpTo(
+        NftId nftId, 
+        Amount maxRewardAmount
+    )
+        external
+        returns (Amount rewardsClaimedAmount);
+
+
+    function unstakeUpTo(
+        NftId nftId, 
+        Amount maxUnstakeAmount,
+        Amount maxClaimAmount
+    )
+        external
+        returns (
+            Amount unstakedAmount,
+            Amount claimedAmount
+        );
+
+    //--- view functions -----------------------------------------------//
+
+    function getTargetManager() external view returns (NftIdSetManager targetManager);
+
+    function getStakeBalance(NftId nftId) external view returns (Amount balanceAmount);
+    function getRewardBalance(NftId nftId) external view returns (Amount rewardAmount);
+    function getBalanceUpdatedAt(NftId nftId) external view returns (Timestamp updatedAt);
+
+    function getBalanceAndLastUpdatedAt(NftId nftId)
+        external
+        view
+        returns (
+            Amount stakeBalance,
+            Timestamp lastUpdatedAt
+        );
+}

package/contracts/staking/StakeManagerLib.sol

@@ -0,0 +1,156 @@
+// 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 {Timestamp, TimestampLib} from "../type/Timestamp.sol";
+import {UFixed, UFixedLib} from "../type/UFixed.sol";
+
+
+library StakeManagerLib {
+
+    function checkActiveTarget(
+        StakingReader stakingReader,
+        NftId targetNftId
+    )
+        public
+        view
+    {
+        // 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);
+        }
+    }
+
+
+    function checkStakeParameters(
+        StakingReader stakingReader,
+        NftId targetNftId, 
+        Amount dipAmount
+    )
+        external
+        view
+        returns (
+            Timestamp lockedUntil
+        )
+    {
+        // 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);
+        }
+
+        checkDipAmount(targetNftId, dipAmount);
+
+        Timestamp currentTime = TimestampLib.blockTimestamp();
+        lockedUntil = currentTime.addSeconds(
+            stakingReader.getTargetInfo(targetNftId).lockingPeriod);
+    }
+
+
+    function checkDipAmount(
+        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 checkDipBalanceAndAllowance(
+        IERC20Metadata dip, 
+        address owner, 
+        address tokenHandlerAddress, 
+        Amount dipAmount
+    )
+        public
+        view
+    {
+        // check balance
+        uint256 amount = dipAmount.toInt();
+        uint256 dipBalance = dip.balanceOf(owner);
+        if (dipBalance < amount) {
+            revert IStaking.ErrorStakingDipBalanceInsufficient(owner, amount, dipBalance);
+        }
+
+        // check allowance
+        uint256 dipAllowance = dip.allowance(owner, tokenHandlerAddress);
+        if (dipAllowance < amount) {
+            revert IStaking.ErrorStakingDipAllowanceInsufficient(owner, tokenHandlerAddress, amount, dipAllowance);
+        }
+    }
+
+
+    function calculateRewardIncrease(
+        StakingReader stakingReader,
+        NftId stakeNftId
+    )
+        public
+        view
+        returns (Amount rewardIncreaseAmount)
+    {
+        (
+            UFixed rewardRate,
+            Amount stakeAmount,
+            Timestamp lastUpdatedAt
+        ) = stakingReader.getRewardCalculationInput(stakeNftId);
+
+        Seconds duration = SecondsLib.toSeconds(
+            block.timestamp - lastUpdatedAt.toInt());
+        
+        rewardIncreaseAmount = calculateRewardAmount(
+            rewardRate,
+            duration,
+            stakeAmount);
+    }
+
+
+    function calculateRewardAmount(
+        UFixed rewardRate,
+        Seconds duration, 
+        Amount stakeAmount
+    )
+        public 
+        pure 
+        returns(
+            Amount rewardAmount
+        )
+    {
+        UFixed yearFraction = getYearFraction(duration);
+        UFixed rewardRateFraction = yearFraction * rewardRate;
+        UFixed amountUFixed = rewardRateFraction * stakeAmount.toUFixed();
+        rewardAmount = AmountLib.toAmount(amountUFixed.toInt());
+    }
+
+
+    function getYearFraction(Seconds duration) public pure returns (UFixed yearFraction) {
+        return UFixedLib.toUFixed(duration.toInt()) / UFixedLib.toUFixed(SecondsLib.oneYear().toInt());
+    }
+
+}