@etherisc/gif-next 0.0.2-da77c50-824 → 0.0.2-da87b00-860

package/contracts/staking/TargetHandler.sol

@@ -0,0 +1,132 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {AccessManaged} from "@openzeppelin/contracts/access/manager/AccessManaged.sol";
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
+
+import {IRegistry} from "../registry/IRegistry.sol";
+import {ITargetLimitHandler} from "./ITargetLimitHandler.sol";
+
+import {Amount, AmountLib} from "../type/Amount.sol";
+import {Blocknumber, BlocknumberLib} from "../type/Blocknumber.sol";
+import {NftId} from "../type/NftId.sol";
+import {StakingStore} from "./StakingStore.sol";
+import {UFixed, UFixedLib} from "../type/UFixed.sol";
+
+
+contract TargetHandler is
+    Initializable,
+    AccessManaged,
+    ITargetLimitHandler
+{
+
+    event LogTargetHandlerUpdateTriggersSet(uint16 tvlUpdatesTrigger, UFixed minTvlRatioTrigger, Blocknumber lastUpdateIn);
+
+    IRegistry private _registry;
+    StakingStore private _store;
+
+    /// @dev Update trigger value: Number of TVL updates below which limit updates are suppressed
+    uint16 private _tvlUpdatesTrigger; 
+    /// @dev Maximum TVL ratio: Any ratio above this value will trigger a limit update
+    UFixed private _minTvlRatioTrigger;
+    Blocknumber private _lastUpdateIn;
+
+
+    constructor (
+        IRegistry registry,
+        StakingStore stakingStore
+    )
+        AccessManaged(msg.sender)
+    {
+        // set final authority and registry
+        setAuthority(registry.getAuthority());
+        _registry = registry;
+        _store = stakingStore;
+
+        // set default trigger values
+        _setUpdateTriggers(
+            10, // check after 2 TVL updates
+            UFixedLib.toUFixed(1, -1)); // 10% deviation from baseline TVL
+    }
+
+
+    // TODO do we really need this?
+    // if so: add onlyDeployer (new base contract? also for reader)
+    // if not: remove oz intializer/initializable
+    function initialize()
+        external
+        initializer()
+    { }
+
+    //--- staking functions -------------------------------------------------------//
+
+    /// @dev Sets the TVL update triggers.
+    function setUpdateTriggers(
+        uint16 tvlUpdatesTrigger,
+        UFixed minTvlRatioTrigger
+    )
+        external
+        restricted()
+    {
+        _setUpdateTriggers(tvlUpdatesTrigger, minTvlRatioTrigger);
+    }
+
+    //--- ITargetLimitHandler -----------------------------------------------------//
+
+    /// @inheritdoc ITargetLimitHandler
+    // Current implementation only considers the TVL amounts. 
+    // Future implementations may also consider target or token specific factors. 
+    function isLimitUpdateRequired(
+        NftId, // targetNftId
+        address , // token
+        uint16 tvlUpdatesCount,
+        Amount baselineTvlAmount, 
+        Amount currentTvlAmount
+    )
+        external 
+        virtual
+        view
+        returns (bool updateIsRequired)
+    {
+        // no update required if below the TVL updates trigger
+        if (tvlUpdatesCount < _tvlUpdatesTrigger) {
+            return false;
+        }
+
+        // no update required if both amounts are zero
+        Amount zero = AmountLib.zero();
+        if (baselineTvlAmount == zero && currentTvlAmount == zero) {
+            return false;
+
+        // update required if one amount is zero
+        } else if (baselineTvlAmount == zero || currentTvlAmount == zero) {
+            return true;
+        }
+
+        // calculate the ratio of the current TVL amount to the baseline TVL amount
+        UFixed baseline = baselineTvlAmount.toUFixed();
+        UFixed current = currentTvlAmount.toUFixed();
+        UFixed ratio;
+
+        if (baseline > current) { ratio = baseline / current; }
+        else { ratio = current / baseline; }
+
+        // update required if the ratio is above the maximum TVL ratio
+        return ratio >= _minTvlRatioTrigger;
+    }
+
+
+    function _setUpdateTriggers(
+        uint16 tvlUpdatesTrigger,
+        UFixed minTvlRatioTrigger
+    )
+        internal
+    {
+        Blocknumber lastUpdateIn = _lastUpdateIn;
+        _tvlUpdatesTrigger = tvlUpdatesTrigger;
+        _minTvlRatioTrigger = minTvlRatioTrigger;
+        _lastUpdateIn = BlocknumberLib.current();
+
+        emit LogTargetHandlerUpdateTriggersSet(tvlUpdatesTrigger, minTvlRatioTrigger, lastUpdateIn);
+    }
+}

package/contracts/staking/TargetManagerLib.sol

@@ -0,0 +1,234 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+import {IStaking} from "./IStaking.sol";
+
+import {Amount, AmountLib} from "../type/Amount.sol";
+import {ChainIdLib} from "../type/ChainId.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 {UFixed, UFixedLib} from "../type/UFixed.sol";
+
+
+library TargetManagerLib {
+
+    function updateLockingPeriod(
+        IStaking staking,
+        NftId targetNftId, 
+        Seconds lockingPeriod
+    )
+        external
+        view
+        returns (
+            Seconds oldLockingPeriod,
+            IStaking.TargetInfo memory targetInfo
+        )
+    {
+        StakingReader reader = staking.getStakingReader();
+
+        // check target exists
+        if(!reader.isTarget(targetNftId)) {
+            revert IStaking.ErrorStakingTargetNotFound(targetNftId);
+        }
+
+        ObjectType targetType = reader.getTargetInfo(targetNftId).objectType;
+        checkLockingPeriod(reader, targetNftId, targetType, lockingPeriod);
+
+        targetInfo = reader.getTargetInfo(targetNftId);
+        oldLockingPeriod = targetInfo.lockingPeriod;
+
+        targetInfo.lockingPeriod = lockingPeriod;
+    }
+
+
+    function updateRewardRate(
+        IStaking staking,
+        NftId targetNftId, 
+        UFixed rewardRate
+    )
+        external
+        view
+        returns (
+            UFixed oldRewardRate,
+            IStaking.TargetInfo memory targetInfo
+        )
+    {
+        StakingReader reader = staking.getStakingReader();
+
+        // check target exists
+        if(!reader.isTarget(targetNftId)) {
+            revert IStaking.ErrorStakingTargetNotFound(targetNftId);
+        }
+
+        ObjectType targetType = reader.getTargetInfo(targetNftId).objectType;
+        checkRewardRate(reader, targetNftId, targetType, rewardRate);
+
+        targetInfo = reader.getTargetInfo(targetNftId);
+        oldRewardRate = targetInfo.rewardRate;
+
+        targetInfo.rewardRate = rewardRate;
+    }
+
+
+    function checkTargetParameters(
+        IRegistry registry,
+        StakingReader stakingReader,
+        NftId targetNftId,
+        ObjectType expectedObjectType,
+        Seconds lockingPeriod,
+        UFixed rewardRate
+    )
+        external
+        view
+    {
+        // target nft id must not be zero
+        if (targetNftId.eqz()) {
+            revert IStaking.ErrorStakingTargetNftIdZero();
+        }
+
+        // only accept "new" targets to be registered
+        if (stakingReader.isTarget(targetNftId)) {
+            revert IStaking.ErrorStakingTargetAlreadyRegistered(targetNftId);
+        }
+
+        // get setup info for additional checks
+        IStaking.SupportInfo memory supportInfo = stakingReader.getSupportInfo(expectedObjectType);
+
+        // check if type is supported and new targets of that type are allowed
+        if (!(supportInfo.isSupported && supportInfo.allowNewTargets)) {
+            revert IStaking.ErrorStakingTargetTypeNotSupported(targetNftId, expectedObjectType);
+        }
+
+        // check if cross chain targets are allowed (if applicable)
+        bool isCurrentChain = ChainIdLib.isCurrentChain(targetNftId);
+        if (!supportInfo.allowCrossChain && !isCurrentChain) {
+            revert IStaking.ErrorStakingCrossChainTargetsNotSupported(targetNftId, expectedObjectType);
+        }
+
+        // additional check for current chain target: target nft id must be known and registered with the expected object type
+        if (isCurrentChain) {
+            if (!registry.isRegistered(targetNftId)) {
+                revert IStaking.ErrorStakingTargetNotFound(targetNftId);
+            } else {
+                // check that expected object type matches with registered object type
+                ObjectType actualObjectType = registry.getObjectInfo(targetNftId).objectType;
+                if (actualObjectType != expectedObjectType) {
+                    revert IStaking.ErrorStakingTargetUnexpectedObjectType(targetNftId, expectedObjectType, actualObjectType);
+                }
+            }
+        }
+
+        // check locking period and reward rate
+        _checkLockingPeriod(targetNftId, lockingPeriod, supportInfo);
+        _checkRewardRate(targetNftId, rewardRate, supportInfo);
+    }
+
+
+    function checkLockingPeriod(StakingReader reader, NftId targetNftId, ObjectType targetType, Seconds lockingPeriod)
+        public 
+        view
+    {
+        IStaking.SupportInfo memory supportInfo = reader.getSupportInfo(targetType);
+        _checkLockingPeriod(targetNftId, lockingPeriod, supportInfo);
+    }
+
+
+    function checkRewardRate(StakingReader reader, NftId targetNftId, ObjectType targetType, UFixed rewardRate)
+        public
+        view
+    {
+        IStaking.SupportInfo memory supportInfo = reader.getSupportInfo(targetType);
+        _checkRewardRate(targetNftId, rewardRate, supportInfo);
+    }
+
+
+    function calculateRequiredDipAmount(
+        Amount tokenAmount,
+        UFixed stakingRate
+    )
+        public
+        pure
+        returns (Amount dipAmount)
+    {
+        dipAmount = tokenAmount.multiplyWith(stakingRate);
+    }
+
+
+    function calculateStakingRate(
+        IERC20Metadata dipToken,
+        IERC20Metadata token,
+        UFixed requiredDipPerToken
+    )
+        public
+        view
+        returns (UFixed stakingRate)
+    {
+        UFixed decimalsFactor = UFixedLib.toUFixed(1, int8(dipToken.decimals() - token.decimals()));
+        stakingRate = requiredDipPerToken * decimalsFactor;
+    }
+
+
+    function getMaxLockingPeriod() public pure returns (Seconds maxLockingPeriod) {
+        return SecondsLib.toSeconds(5 * 365 * 24 * 3600);
+    }
+
+
+    function getDefaultLockingPeriod() public pure returns (Seconds maxLockingPeriod) {
+        return SecondsLib.toSeconds(365 * 24 * 3600 / 2);
+    }
+
+    /// @dev the minimum locking period is 24 hours
+    function getMinimumLockingPeriod() public pure returns (Seconds minLockingPeriod) {
+        return SecondsLib.toSeconds(24 * 3600);
+    }
+
+    function getMaxRewardRate() public pure returns (UFixed maxRewardRate) {
+        return UFixedLib.toUFixed(33, -2);
+    }
+
+
+    function getDefaultRewardRate() public pure returns (UFixed defaultRewardRate) {
+        return UFixedLib.toUFixed(5, -2);
+    }
+
+
+    function toTargetKey(NftId targetNftId) public pure returns (Key32 targetKey) {
+        return targetNftId.toKey32(TARGET());
+    }
+
+
+    function _checkLockingPeriod(NftId targetNftId, Seconds lockingPeriod, IStaking.SupportInfo memory supportInfo)
+        private
+        pure
+    {
+        if (lockingPeriod < supportInfo.minLockingPeriod || lockingPeriod > supportInfo.maxLockingPeriod) {
+            revert IStaking.ErrorStakingLockingPeriodInvalid(
+                targetNftId, 
+                lockingPeriod, 
+                supportInfo.minLockingPeriod,
+                supportInfo.maxLockingPeriod);
+        }
+    }
+
+
+    function _checkRewardRate(NftId targetNftId, UFixed rewardRate, IStaking.SupportInfo memory supportInfo) 
+        private
+        pure
+    {
+        if (rewardRate < supportInfo.minRewardRate || rewardRate > supportInfo.maxRewardRate) {
+            revert IStaking.ErrorStakingRewardRateInvalid(
+                targetNftId, 
+                rewardRate,
+                supportInfo.minRewardRate,
+                supportInfo.maxRewardRate);
+        }
+    }
+}

package/contracts/{types → type}/AddressSet.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 // based on https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/structs/EnumerableSet.sol
 library LibAddressSet {

package/contracts/type/Amount.sol

@@ -0,0 +1,154 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {UFixed, UFixedLib} from "./UFixed.sol";
+
+/// @dev Targets: 100 trillion (worlds GDP) with 6 decimal places
+/// 3 trillion USD (total crypto market cap) with 12 decimal places.
+/// 2023 100 trillion USD => 100e12 * 1e6 = 1e20
+/// 2024 2 trillion crypto market cap => 2e12 * 1e18 = 2e30
+type Amount is uint96;
+
+using {
+    addAmount as +,
+    subAmount as -,
+    eqAmount as ==,
+    nqAmount as !=,
+    ltAmount as <,
+    ltAmount as <=,
+    gtAmount as >,
+    gteAmount as >=,
+    AmountLib.add,
+    AmountLib.eq,
+    AmountLib.eqz,
+    AmountLib.gtz,
+    AmountLib.gt,
+    AmountLib.gte,
+    AmountLib.multiplyWith,
+    AmountLib.toInt,
+    AmountLib.toUFixed
+} for Amount global;
+
+function addAmount(Amount a, Amount b) pure returns (Amount) {
+    return AmountLib.add(a, b);
+}
+
+function subAmount(Amount a, Amount b) pure returns (Amount) {
+    return AmountLib.sub(a, b);
+}
+
+function eqAmount(Amount a, Amount b) pure returns (bool) {
+    return AmountLib.eq(a, b);
+}
+
+function nqAmount(Amount a, Amount b) pure returns (bool) {
+    return !AmountLib.eq(a, b);
+}
+
+function ltAmount(Amount a, Amount b) pure returns (bool) {
+    return AmountLib.lt(a, b);
+}
+
+function lteAmount(Amount a, Amount b) pure returns (bool) {
+    return AmountLib.lte(a, b);
+}
+
+function gtAmount(Amount a, Amount b) pure returns (bool) {
+    return AmountLib.gt(a, b);
+}
+
+function gteAmount(Amount a, Amount b) pure returns (bool) {
+    return AmountLib.gte(a, b);
+}
+
+library AmountLib {
+
+    error ErrorAmountLibValueTooBig(uint256 amount);
+
+    function zero() public pure returns (Amount) {
+        return Amount.wrap(0);
+    }
+
+    function max() public pure returns (Amount) {
+        return Amount.wrap(_max());
+    }
+
+    /// @dev converts the uint amount into Amount
+    /// function reverts if value is exceeding max Amount value
+    function toAmount(uint256 amount) public pure returns (Amount) {
+        if(amount > _max()) {
+            revert ErrorAmountLibValueTooBig(amount);
+        }
+
+        return Amount.wrap(uint96(amount));
+    }
+
+    /// @dev return true if amount equals 0
+    function eqz(Amount amount) public pure returns (bool) {
+        return Amount.unwrap(amount) == 0;
+    }
+
+    /// @dev return true if amount1 equals amount2
+    function eq(Amount amount1, Amount amount2) public pure returns (bool) {
+        return Amount.unwrap(amount1) == Amount.unwrap(amount2);
+    }
+
+    /// @dev return true if amount a1 is less than a2
+    function lt(Amount a1, Amount a2) public pure returns (bool) {
+        return Amount.unwrap(a1) < Amount.unwrap(a2);
+    }
+
+    /// @dev return true if amount a1 is less or equal than a2
+    function lte(Amount a1, Amount a2) public pure returns (bool) {
+        return Amount.unwrap(a1) <= Amount.unwrap(a2);
+    }
+
+    /// @dev return true if amount a1 is greater than a2
+    function gt(Amount a1, Amount a2) public pure returns (bool) {
+        return Amount.unwrap(a1) > Amount.unwrap(a2);
+    }
+
+    /// @dev return true if amount a1 is greater or equal than a2
+    function gte(Amount a1, Amount a2) public pure returns (bool) {
+        return Amount.unwrap(a1) >= Amount.unwrap(a2);
+    }
+
+    /// @dev return minimum of a1 and a2.
+    function min(Amount a1, Amount a2) public pure returns (Amount) {
+        if (Amount.unwrap(a1) < Amount.unwrap(a2)) {
+            return a1;
+        }
+
+        return a2;
+    }
+
+    /// @dev return true if amount is larger than 0
+    function gtz(Amount amount) public pure returns (bool) {
+        return Amount.unwrap(amount) > 0;
+    }
+
+    function add(Amount a1, Amount a2) public pure returns (Amount) {
+        return Amount.wrap(Amount.unwrap(a1) + Amount.unwrap(a2));
+    }
+
+    function sub(Amount a1, Amount a2) public pure returns (Amount) {
+        return Amount.wrap(Amount.unwrap(a1) - Amount.unwrap(a2));
+    }
+
+    function toInt(Amount amount) public pure returns (uint256) {
+        return uint256(uint96(Amount.unwrap(amount)));
+    }
+
+    function toUFixed(Amount amount) public pure returns (UFixed) {
+        return UFixedLib.toUFixed(Amount.unwrap(amount));
+    }
+
+    function multiplyWith(Amount amount, UFixed factor) public pure returns (Amount) {
+        return toAmount((factor * UFixedLib.toUFixed(Amount.unwrap(amount))).toInt());
+    }
+
+    function _max() internal pure returns (uint96) {
+        // IMPORTANT: type nees to match with actual definition for Amount
+        return type(uint96).max;
+    }
+}

package/contracts/{types → type}/Blocknumber.sol

@@ -1,7 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
-type Blocknumber is uint32;
+/// @dev Target: Cover 10 years with 1 ms block times.
+/// Typical block times are a few seconds.
+type Blocknumber is uint40;
 
 using {
     gtBlocknumber as >,
@@ -10,7 +12,15 @@ using {
     lteBlocknumber as <=,
     eqBlocknumber as ==,
     neBlocknumber as !=,
-    BlocknumberLib.toInt
+    BlocknumberLib.toInt,
+    BlocknumberLib.eq,
+    BlocknumberLib.ne,
+    BlocknumberLib.eqz,
+    BlocknumberLib.gtz,
+    BlocknumberLib.gt,
+    BlocknumberLib.gte,
+    BlocknumberLib.lt,
+    BlocknumberLib.lte
 } for Blocknumber global;
 
 /// @dev return true if Blocknumber a is greater than Blocknumber b
@@ -48,21 +58,35 @@ function toBlocknumber(uint256 blocknum) pure returns (Blocknumber) {
     return Blocknumber.wrap(uint32(blocknum));
 }
 
-function blockBlocknumber() view returns (Blocknumber) {
-    return toBlocknumber(block.number);
-}
-
-/// @dev Return the Blocknumber zero (0)
-function zeroBlocknumber() pure returns (Blocknumber) {
-    return toBlocknumber(0);
-}
-
 /// @dev Return the current block number
 function blockNumber() view returns (Blocknumber) {
     return toBlocknumber(block.number);
 }
 
 library BlocknumberLib {
+
+    function zero() public pure returns (Blocknumber) {
+        return Blocknumber.wrap(0);
+    }
+
+    function max() public pure returns (Blocknumber) {
+        return Blocknumber.wrap(type(uint40).max);
+    }
+
+    function current() public view returns (Blocknumber) {
+        return Blocknumber.wrap(uint40(block.number));
+    }
+
+    /// @dev return true iff blocknumber is 0
+    function eqz(Blocknumber blocknumber) public pure returns (bool) {
+        return Blocknumber.unwrap(blocknumber) == 0;
+    }
+
+    /// @dev return true iff blocknumber is > 0
+    function gtz(Blocknumber blocknumber) public pure returns (bool) {
+        return Blocknumber.unwrap(blocknumber) > 0;
+    }
+
     /// @dev return true if Blocknumber a is greater than Blocknumber b
     function gt(
         Blocknumber a,

package/contracts/type/ChainId.sol

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {NftId} from "./NftId.sol";
+
+/// @dev Target: Cover chain IDs up to 26 decimal places.
+/// Current longest chain ID seems to be DCHAIN Testnet: 2713017997578000 with 16 decimal places 
+type ChainId is uint96;
+
+using {
+    eqChainId as ==,
+    neChainId as !=,
+    ChainIdLib.toInt,
+    ChainIdLib.eqz,
+    ChainIdLib.gtz
+} for ChainId global;
+
+
+/// @dev return true if ChainId a is equal to ChainId b
+function eqChainId(ChainId a, ChainId b) pure returns (bool) {
+    return ChainId.unwrap(a) == ChainId.unwrap(b);
+}
+
+/// @dev return true if ChainId a is not equal to ChainId b
+function neChainId(ChainId a, ChainId b) pure returns (bool) {
+    return ChainId.unwrap(a) != ChainId.unwrap(b);
+}
+
+
+library ChainIdLib {
+
+    error ErrorChainIdLibValueTooBig(uint256 chainId);
+
+
+    function zero() public pure returns (ChainId) {
+        return ChainId.wrap(0);
+    }
+
+
+    function max() public pure returns (ChainId) {
+        return ChainId.wrap(_max());
+    }
+
+
+    function current() public view returns (ChainId) {
+        return toChainId(block.chainid);
+    }
+
+
+    /// @dev return true iff chainId is 0
+    function eqz(ChainId chainId) public pure returns (bool) {
+        return ChainId.unwrap(chainId) == 0;
+    }
+
+
+    /// @dev return true iff chainId is > 0
+    function gtz(ChainId chainId) public pure returns (bool) {
+        return ChainId.unwrap(chainId) > 0;
+    }
+
+
+    /// @dev converts the uint into ChainId
+    /// function reverts if value is exceeding max ChainId value
+    function toChainId(uint256 chainId) public pure returns (ChainId) {
+        if(chainId > _max()) {
+            revert ErrorChainIdLibValueTooBig(chainId);
+        }
+
+        return ChainId.wrap(uint96(chainId));
+    }
+
+
+    /// @dev returns true iff NFT ID is from the current chain.
+    function isCurrentChain(NftId nftId) public view returns (bool) {
+        return _fromNftId(nftId) == block.chainid;
+    }
+
+
+    function fromNftId(NftId nftId) public pure returns (ChainId) {
+        return toChainId(_fromNftId(nftId));
+    }
+
+
+    /// @dev converts the ChainId to a uint256
+    function toInt(ChainId chainId) public pure returns (uint256) {
+        return uint256(uint96(ChainId.unwrap(chainId)));
+    }
+
+
+    function _fromNftId(NftId nftId) internal pure returns (uint256 chainIdInt) {
+        uint256 nftIdInt = nftId.toInt();
+        uint256 chainIdDigits = nftIdInt % 100; // Extract the last two digits
+        chainIdInt = nftIdInt % 10**(chainIdDigits + 2) / 100; // Extract the chainId
+    }
+
+
+    function _max() internal pure returns (uint96) {
+        // IMPORTANT: type nees to match with actual definition for Amount
+        return type(uint96).max;
+    }
+}