@etherisc/gif-next 0.0.2-e769e2e-077 → 0.0.2-e7a5428-226

package/contracts/staking/TargetManagerLib.sol

@@ -0,0 +1,211 @@
+// 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 {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);
+        }
+
+        checkLockingPeriod(targetNftId, 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);
+        }
+
+        checkRewardRate(targetNftId, rewardRate);
+
+        targetInfo = reader.getTargetInfo(targetNftId);
+        oldRewardRate = targetInfo.rewardRate;
+
+        targetInfo.rewardRate = rewardRate;
+    }
+
+
+    function checkTargetParameters(
+        IRegistry registry,
+        StakingReader stakingReader,
+        NftId targetNftId,
+        ObjectType expectedObjectType,
+        Seconds initialLockingPeriod,
+        UFixed initialRewardRate
+    )
+        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);
+        }
+
+        // target object type must be allowed
+        if (!isTargetTypeSupported(expectedObjectType)) {
+            revert IStaking.ErrorStakingTargetTypeNotSupported(targetNftId, expectedObjectType);
+        }
+
+        checkLockingPeriod(targetNftId, initialLockingPeriod);
+        checkRewardRate(targetNftId, initialRewardRate);
+
+        // target nft id must be known and registered with the expected object type
+        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);
+            }
+        }
+    }
+
+
+    function isTargetTypeSupported(ObjectType objectType)
+        public 
+        pure 
+        returns (bool isSupported)
+    {
+        if(objectType == PROTOCOL()) { return true; }
+        if(objectType == INSTANCE()) { return true; }
+
+        return false;
+    }
+
+
+    function checkLockingPeriod(NftId targetNftId, Seconds lockingPeriod)
+        public 
+        pure
+    {
+        // check locking period is >= min locking period
+        if (lockingPeriod.lt(getMinimumLockingPeriod())) {
+            revert IStaking.ErrorStakingLockingPeriodTooShort(targetNftId, getMinimumLockingPeriod(), lockingPeriod);
+        }
+
+        // check locking period <= max locking period
+        if (lockingPeriod > getMaxLockingPeriod()) {
+            revert IStaking.ErrorStakingLockingPeriodTooLong(targetNftId, getMaxLockingPeriod(), lockingPeriod);
+        }
+    }
+
+
+    function checkRewardRate(NftId targetNftId, UFixed rewardRate)
+        public
+        pure
+    {
+        // check reward rate <= max reward rate
+        if (rewardRate > getMaxRewardRate()) {
+            revert IStaking.ErrorStakingRewardRateTooHigh(targetNftId, getMaxRewardRate(), rewardRate);
+        }
+    }
+
+
+    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());
+    }
+}

package/contracts/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

@@ -3,6 +3,10 @@ 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 {
@@ -11,12 +15,17 @@ using {
     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.add,
     AmountLib.toUFixed
 } for Amount global;
 
@@ -40,10 +49,18 @@ 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);
@@ -76,16 +93,35 @@ library AmountLib {
         return Amount.unwrap(amount1) == Amount.unwrap(amount2);
     }
 
-    /// @dev return true if amount a1 is smaller than a2
+    /// @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 larger than 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;
@@ -107,6 +143,10 @@ library AmountLib {
         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/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,25 +58,33 @@ function toBlocknumber(uint256 blocknum) pure returns (Blocknumber) {
     return Blocknumber.wrap(uint32(blocknum));
 }
 
-function blockBlocknumber() view returns (Blocknumber) {
-    return BlocknumberLib.currentBlocknumber();
-}
-
-// TODO move to BlocknumberLib and rename to zero()
-/// @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 {
-    /// @dev returns the current Blocknumber
-    function currentBlocknumber() public view returns (Blocknumber) {
-        return Blocknumber.wrap(uint32(block.number));
+
+    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

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

package/contracts/type/ClaimId.sol

@@ -12,6 +12,7 @@ import {NftId} from "./NftId.sol";
 using {
     eqClaimId as ==, 
     neClaimId as !=, 
+    ClaimIdLib.eq,
     ClaimIdLib.eqz,
     ClaimIdLib.gtz,
     ClaimIdLib.toInt,
@@ -21,7 +22,7 @@ using {
 
 // pure free functions for operators
 function eqClaimId(ClaimId a, ClaimId b) pure returns (bool isSame) {
-    return ClaimId.unwrap(a) == ClaimId.unwrap(b);
+    return ClaimIdLib.eq(a, b);
 }
 
 function neClaimId(ClaimId a, ClaimId b) pure returns (bool isDifferent) {
@@ -68,6 +69,10 @@ library ClaimIdLib {
         return ClaimId.unwrap(a) > 0;
     }
 
+    function eq(ClaimId a, ClaimId b) public pure returns (bool) {
+        return ClaimId.unwrap(a) == ClaimId.unwrap(b);
+    }
+
     /// @dev Returns true if the value is zero (== 0).
     function eqz(ClaimId a) public pure returns (bool) {
         return ClaimId.unwrap(a) == 0;

package/contracts/type/Fee.sol

@@ -1,20 +1,20 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import {Amount, AmountLib} from "./Amount.sol";
 import {UFixed, UFixedLib} from "./UFixed.sol";
 
 struct Fee {
+    // slot 0
     UFixed fractionalFee;
-    // TODO migrate fixed fee to Amount
-    uint256 fixedFee;
+    Amount fixedFee;
 }
 
 library FeeLib {
 
     /// @dev Return a zero fee struct (0, 0)
     function zero() public pure returns (Fee memory fee) {
-        return Fee(UFixed.wrap(0), 0);
+        return Fee(UFixed.wrap(0), AmountLib.zero());
     }
 
     /// @dev Converts the uint256 to a fee struct.
@@ -22,7 +22,7 @@ library FeeLib {
         UFixed fractionalFee,
         uint256 fixedFee
     ) public pure returns (Fee memory fee) {
-        return Fee(fractionalFee, fixedFee);
+        return Fee(fractionalFee, AmountLib.toAmount(fixedFee));
     }
 
     /// @dev Calculates fee and net amounts for the provided parameters
@@ -41,14 +41,14 @@ library FeeLib {
         if(gtz(fee)) {
             UFixed fractionalAmount = 
                 amount.toUFixed() * fee.fractionalFee;
-            feeAmount = AmountLib.toAmount(fractionalAmount.toInt() + fee.fixedFee);
+            feeAmount = AmountLib.toAmount(fractionalAmount.toInt()) + fee.fixedFee;
             netAmount = netAmount - feeAmount;
         }
     }
 
     /// @dev Return the percent fee struct (x%, 0)
     function percentageFee(uint8 percent) public pure returns (Fee memory fee) {
-        return Fee(UFixedLib.toUFixed(percent, -2), 0);
+        return Fee(UFixedLib.toUFixed(percent, -2), AmountLib.zero());
     }
 
     // pure free functions for operators
@@ -57,10 +57,10 @@ library FeeLib {
     }
 
     function gtz(Fee memory fee) public pure returns (bool) {
-        return UFixed.unwrap(fee.fractionalFee) > 0 || fee.fixedFee > 0;
+        return UFixed.unwrap(fee.fractionalFee) > 0 || fee.fixedFee.gtz();
     }
 
     function eqz(Fee memory fee) public pure returns (bool) {
-        return fee.fixedFee == 0 && UFixed.unwrap(fee.fractionalFee) == 0;
+        return fee.fixedFee.eqz() && UFixed.unwrap(fee.fractionalFee) == 0;
     }
 }

package/contracts/type/Key32.sol

@@ -28,8 +28,8 @@ library Key32Lib {
 
     uint8 public constant TYPE_SHIFT = 31 * 8;
     uint8 public constant ID_SHIFT = uint8(32 * 8 - TYPE_SHIFT);
-    bytes32 public constant TYPE_MASK = bytes32(bytes1(type(uint8).max)); // first byte in bytes32
-    bytes32 public constant ID_MASK = bytes32(~TYPE_MASK); // remaining bytes in bytes32
+    bytes32 public constant TYPE_MASK = bytes32(bytes1(type(uint8).max)); // [32] byte in bytes32
+    bytes32 public constant ID_MASK = bytes32(~TYPE_MASK); // [0..31] bytes in bytes32
 
     function toKey32(ObjectType objectType, KeyId id) public pure returns (Key32) {
         uint256 uintObjectType = ObjectType.unwrap(objectType);

package/contracts/type/Key32Set.sol

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Key32} from "../type/Key32.sol";
+
+// based on https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/structs/EnumerableSet.sol
+library LibKey32Set {
+
+    struct Set {
+        Key32[] keys;
+        mapping(Key32 key => uint256 index) at;
+    }
+
+    error ErrorKey32SetAlreadyAdded(Key32 key);
+    error ErrorKey32SetNotInSet(Key32 key);
+
+
+    function add(Set storage set, Key32 key) external {
+        if (set.at[key] > 0) {
+            revert ErrorKey32SetAlreadyAdded(key);
+        }
+
+        set.keys.push(key);
+        set.at[key] = set.keys.length;
+    }
+
+    function remove(Set storage set, Key32 key) external {
+        uint256 nftIdIndex = set.at[key];
+
+        if (nftIdIndex == 0) {
+            revert ErrorKey32SetNotInSet(key);
+        }
+
+        uint256 toDeleteIndex = nftIdIndex - 1;
+        uint256 lastIndex = set.keys.length - 1;
+
+        if (lastIndex != toDeleteIndex) {
+            Key32 lastId = set.keys[lastIndex];
+            set.keys[toDeleteIndex] = lastId;
+            set.at[lastId] = nftIdIndex; // Replace lastValue's index to valueIndex
+        }
+
+        set.keys.pop();
+        delete set.at[key];
+    }
+
+    function isEmpty(Set storage set) external view returns(bool empty) {
+        return set.keys.length == 0;
+    }
+
+    function contains(Set storage set, Key32 key) external view returns(bool inSet) {
+        return set.at[key] > 0;
+    }
+
+    function size(Set storage set) external view returns(uint256 length) {
+        return set.keys.length;
+    }
+
+    function getElementAt(Set storage set, uint256 index) external view returns(Key32 key) {
+        return set.keys[index];
+    }
+}