@etherisc/gif-next 0.0.2-fc8b370-882 → 0.0.2-fd2113c-488

package/contracts/staking/TargetManagerLib.sol

@@ -0,0 +1,207 @@
+// 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 > 0
+        if (lockingPeriod.eqz()) {
+            revert IStaking.ErrorStakingLockingPeriodZero(targetNftId);
+        }
+
+        // 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);
+    }
+
+
+    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,128 @@
+// 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 <,
+    gtAmount as >,
+    AmountLib.eq,
+    AmountLib.eqz,
+    AmountLib.gtz,
+    AmountLib.toInt,
+    AmountLib.add,
+    AmountLib.toUFixed,
+    AmountLib.multiplyWith
+} 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 gtAmount(Amount a, Amount b) pure returns (bool) {
+    return AmountLib.gt(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 smaller 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
+    function gt(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,9 @@ using {
     lteBlocknumber as <=,
     eqBlocknumber as ==,
     neBlocknumber as !=,
-    BlocknumberLib.toInt
+    BlocknumberLib.toInt,
+    BlocknumberLib.eqz,
+    BlocknumberLib.gtz
 } for Blocknumber global;
 
 /// @dev return true if Blocknumber a is greater than Blocknumber b
@@ -49,9 +51,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 +66,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/type/ClaimId.sol

@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: Apache-2.0
+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.eqz,
+    ClaimIdLib.gtz,
+    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);
+}
+
+function neClaimId(ClaimId a, ClaimId b) pure returns (bool isDifferent) {
+    return ClaimId.unwrap(a) != ClaimId.unwrap(b);
+}
+
+// library functions that operate on user defined type
+library ClaimIdLib {
+    /// @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) {
+        return ClaimId.wrap(uint16(a));
+    }
+
+    /// @dev Converts the ClaimId to a uint.
+    function toInt(ClaimId a) public pure returns (uint16) {
+        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;
+    }
+
+    /// @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/DistributorType.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Key32, KeyId, Key32Lib} from "./Key32.sol";
+import {NftId} from "./NftId.sol";
+import {DISTRIBUTOR_TYPE} from "./ObjectType.sol";
+
+type DistributorType is bytes8;
+
+// type bindings
+using {
+    eqDistributorType as ==,
+    neDistributorType as !=,
+    DistributorTypeLib.toKey32
+} for DistributorType global;
+
+// general pure free functions
+
+// pure free functions for operators
+function eqDistributorType(
+    DistributorType a, 
+    DistributorType b
+) pure returns (bool isSame) {
+    return DistributorType.unwrap(a) == DistributorType.unwrap(b);
+}
+
+function neDistributorType(
+    DistributorType a,
+    DistributorType b
+) pure returns (bool isDifferent) {
+    return DistributorType.unwrap(a) != DistributorType.unwrap(b);
+}
+
+// library functions that operate on user defined type
+library DistributorTypeLib {
+
+    function zero() public pure returns (DistributorType) {
+        return DistributorType.wrap(bytes8(0));
+    }
+
+    // @dev Converts a referral string into an id.
+    function toDistributorType(NftId distributionNftId, string memory name) public pure returns (DistributorType) {
+        return DistributorType.wrap(bytes8(keccak256(abi.encode(distributionNftId, name))));
+    }
+
+    /// @dev Returns the key32 value for the specified nft id and object type.
+    function toKey32(DistributorType id) public pure returns (Key32 key) {
+        return Key32Lib.toKey32(DISTRIBUTOR_TYPE(), toKeyId(id));
+    }
+
+    /// @dev Returns the key id value for the specified nft id
+    function toKeyId(DistributorType id) public pure returns (KeyId keyId) {
+        return KeyId.wrap(bytes31(DistributorType.unwrap(id)));
+    }
+}

package/contracts/type/Fee.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: Apache-2.0
+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 {
+
+    /// @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.
+    function toFee(
+        UFixed fractionalFee,
+        uint256 fixedFee
+    ) public pure returns (Fee memory fee) {
+        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);
+    }
+
+    // pure free functions for operators
+    function eq(Fee memory a, Fee memory b) public pure returns (bool isSame) {
+        return a.fixedFee == b.fixedFee && a.fractionalFee == b.fractionalFee;
+    }
+
+    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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import {ObjectType} from "./ObjectType.sol";
 
@@ -10,7 +10,8 @@ type KeyId is bytes31;
 using {
     eqKey32 as ==, 
     neKey32 as !=,
-    Key32Lib.toKey
+    Key32Lib.toKeyId,
+    Key32Lib.toObjectType
 } for Key32 global;
 
 // @dev Returns true iff keys are identical
@@ -37,9 +38,13 @@ library Key32Lib {
         return Key32.wrap(bytes32(uintKey));
     }
 
-    function toKey(Key32 key) public pure returns (ObjectType objectType, KeyId id) {
+    function toObjectType(Key32 key) public pure returns (ObjectType objectType) {
         bytes32 key32 = Key32.unwrap(key);
         objectType = ObjectType.wrap(uint8(uint256(key32 & TYPE_MASK) >> TYPE_SHIFT));
+    }
+
+    function toKeyId(Key32 key) public pure returns (KeyId id) {
+        bytes32 key32 = Key32.unwrap(key);
         id = KeyId.wrap(bytes31((key32 & ID_MASK) << ID_SHIFT));
     }
 }

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import {Key32, KeyId, Key32Lib} from "./Key32.sol";
 import {ObjectType} from "./ObjectType.sol";
@@ -18,28 +18,29 @@ using {
     NftIdLib.toKey32
 } for NftId global;
 
-// general pure free functions
-/// @dev Converts the uint256 to a NftId.
-function toNftId(uint256 id) pure returns (NftId) {
-    return NftId.wrap(uint96(id));
-}
-
-/// @dev Return the NftId zero (0)
-function zeroNftId() pure returns (NftId) {
-    return NftId.wrap(0);
-}
-
 // pure free functions for operators
 function eqNftId(NftId a, NftId b) pure returns (bool isSame) {
-    return NftId.unwrap(a) == NftId.unwrap(b);
+    return NftIdLib.eq(a, b);
 }
 
 function neNftId(NftId a, NftId b) pure returns (bool isDifferent) {
-    return NftId.unwrap(a) != NftId.unwrap(b);
+    return NftIdLib.ne(a, b);
 }
 
 // library functions that operate on user defined type
 library NftIdLib {
+
+    /// @dev the zero nft id
+    /// is never a valid nft id and implies a non-initialized value
+    function zero() public pure returns (NftId) {
+        return NftId.wrap(0);
+    }
+
+    /// @dev Converts the uint256 to a NftId.
+    function toNftId(uint256 id) public pure returns (NftId) {
+        return NftId.wrap(uint96(id));
+    }
+
     /// @dev Converts the NftId to a uint256.
     function toInt(NftId nftId) public pure returns (uint96) {
         return uint96(NftId.unwrap(nftId));
@@ -57,7 +58,12 @@ library NftIdLib {
 
     /// @dev Returns true if the values are equal (==).
     function eq(NftId a, NftId b) public pure returns (bool isSame) {
-        return eqNftId(a, b);
+        return NftId.unwrap(a) == NftId.unwrap(b);
+    }
+
+    /// @dev Returns true if the values are not equal (!=).
+    function ne(NftId a, NftId b) public pure returns (bool isSame) {
+        return NftId.unwrap(a) != NftId.unwrap(b);
     }
 
     /// @dev Returns the key32 value for the specified nft id and object type.