@etherisc/gif-next 0.0.2-a733491-751 → 0.0.2-a755cba-454

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
+        view
+        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/{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,150 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {UFixed, UFixedLib} from "./UFixed.sol";
+
+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,5 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 type Blocknumber is uint32;
 
@@ -10,7 +10,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
@@ -49,9 +57,10 @@ function toBlocknumber(uint256 blocknum) pure returns (Blocknumber) {
 }
 
 function blockBlocknumber() view returns (Blocknumber) {
-    return toBlocknumber(block.number);
+    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);
@@ -63,6 +72,21 @@ function blockNumber() view returns (Blocknumber) {
 }
 
 library BlocknumberLib {
+    /// @dev returns the current Blocknumber
+    function currentBlocknumber() public view returns (Blocknumber) {
+        return Blocknumber.wrap(uint32(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/{types → type}/ClaimId.sol

@@ -4,19 +4,25 @@ pragma solidity ^0.8.20;
 // uint16 allows for 65'535 claims per policy
 type ClaimId is uint16;
 
+import {CLAIM} from "./ObjectType.sol";
+import {Key32, KeyId, Key32Lib} from "./Key32.sol";
+import {NftId} from "./NftId.sol";
+
 // type bindings
 using {
     eqClaimId as ==, 
     neClaimId as !=, 
+    ClaimIdLib.eq,
     ClaimIdLib.eqz,
     ClaimIdLib.gtz,
-    ClaimIdLib.toInt
+    ClaimIdLib.toInt,
+    ClaimIdLib.toKey32
 } for ClaimId global;
 
 
 // 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) {
@@ -25,10 +31,14 @@ function neClaimId(ClaimId a, ClaimId b) pure returns (bool isDifferent) {
 
 // library functions that operate on user defined type
 library ClaimIdLib {
-    /// @dev Converts the ClaimId to a uint.
+    /// @dev claim id min value (0), use only for non-initialized values
     function zero() public pure returns (ClaimId) {
         return ClaimId.wrap(0);
     }
+    /// @dev claim id max value (2**16-1), use only for non-initialized values
+    function max() public pure returns (ClaimId) {
+        return ClaimId.wrap(type(uint16).max);
+    }
 
     /// @dev Converts an uint into a ClaimId.
     function toClaimId(uint256 a) public pure returns (ClaimId) {
@@ -40,11 +50,29 @@ library ClaimIdLib {
         return uint16(ClaimId.unwrap(a));
     }
 
+    /// @dev Converts the ClaimId and NftId to a Key32.
+    function toKey32(ClaimId claimId, NftId policyNftId) public pure returns (Key32) {
+        return Key32Lib.toKey32(CLAIM(), toKeyId(claimId, policyNftId));
+    }
+
+    /// @dev Converts the ClaimId and NftId to a Key32.
+    function toKeyId(ClaimId claimId, NftId policyNftId) public pure returns (KeyId) {
+        return KeyId.wrap(
+            bytes31(
+                bytes14(
+                    uint112(
+                        NftId.unwrap(policyNftId) << 16 + ClaimId.unwrap(claimId)))));
+    }
+
     /// @dev Returns true if the value is non-zero (> 0).
     function gtz(ClaimId a) public pure returns (bool) {
         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/{types → type}/Fee.sol

@@ -1,30 +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 {
     UFixed fractionalFee;
+    // TODO migrate fixed fee to Amount
     uint256 fixedFee;
 }
 
 library FeeLib {
 
-    function calculateFee(
-        Fee memory fee,
-        uint256 amount
-    )
-        public
-        pure
-        returns (
-            uint256 feeAmount, 
-            uint256 netAmount
-        )
-    {
-        UFixed fractionalAmount = UFixedLib.toUFixed(amount) *
-            fee.fractionalFee;
-        feeAmount = fractionalAmount.toInt() + fee.fixedFee;
-        netAmount = amount - feeAmount;
+    /// @dev Return a zero fee struct (0, 0)
+    function zero() public pure returns (Fee memory fee) {
+        return Fee(UFixed.wrap(0), 0);
     }
 
     /// @dev Converts the uint256 to a fee struct.
@@ -35,22 +25,42 @@ library FeeLib {
         return Fee(fractionalFee, fixedFee);
     }
 
+    /// @dev Calculates fee and net amounts for the provided parameters
+    function calculateFee(
+        Fee memory fee,
+        Amount amount
+    )
+        public
+        pure
+        returns (
+            Amount feeAmount, 
+            Amount netAmount
+        )
+    {
+        netAmount = amount;
+        if(gtz(fee)) {
+            UFixed fractionalAmount = 
+                amount.toUFixed() * fee.fractionalFee;
+            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);
     }
 
-    /// @dev Return a zero fee struct (0, 0)
-    function zeroFee() public pure returns (Fee memory fee) {
-        return Fee(UFixed.wrap(0), 0);
-    }
-
     // pure free functions for operators
-    function feeIsSame(Fee memory a, Fee memory b) public pure returns (bool isSame) {
+    function eq(Fee memory a, Fee memory b) public pure returns (bool isSame) {
         return a.fixedFee == b.fixedFee && a.fractionalFee == b.fractionalFee;
     }
 
-    function feeIsZero(Fee memory fee) public pure returns (bool) {
+    function gtz(Fee memory fee) public pure returns (bool) {
+        return UFixed.unwrap(fee.fractionalFee) > 0 || fee.fixedFee > 0;
+    }
+
+    function eqz(Fee memory fee) public pure returns (bool) {
         return fee.fixedFee == 0 && UFixed.unwrap(fee.fractionalFee) == 0;
     }
 }

package/contracts/{types → 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];
+    }
+}