@etherisc/gif-next 0.0.2-ecbd488-936 → 0.0.2-ed1536c-164

package/contracts/staking/StakingStore.sol

@@ -0,0 +1,329 @@
+// 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";
+
+
+contract StakingStore is 
+    AccessManaged,
+    KeyValueStore
+{
+
+    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);
+
+    // update balance
+
+    IRegistry private _registry;
+    NftIdSetManager private _targetManager;
+    StakingReader private _reader;
+
+    mapping(NftId nftId => Amount stakes) private _stakeBalance;
+    mapping(NftId nftId => Amount rewards) private _rewardBalance;
+
+    // TODO check if this is made redundant by *Info struct updates
+    mapping(NftId nftId => Timestamp lastUpdatedAt) private _lastUpdatedAt;
+    mapping(NftId nftId => Blocknumber lastUpdatedIn) private _lastUpdatedIn;
+
+
+    constructor(
+        address initialAuthority,
+        address registryAddress
+    )
+        AccessManaged(initialAuthority)
+    {
+        _registry = IRegistry(registryAddress);
+        _reader = new StakingReader();
+        _targetManager = new NftIdSetManager();
+    }
+
+
+    //--- target specific functions ------------------------------------//
+
+    function createTarget(
+        NftId targetNftId,
+        IStaking.TargetInfo memory targetInfo
+    )
+        external
+    {
+        _create(
+            targetNftId.toKey32(TARGET()),
+            abi.encode(targetInfo));
+
+        _createBalance(targetNftId, AmountLib.zero());
+        _targetManager.add(targetNftId);
+    }
+
+
+    function updateTarget(
+        NftId targetNftId, 
+        IStaking.TargetInfo memory targetInfo
+    )
+        external
+    {
+        _update(
+            targetNftId.toKey32(TARGET()), 
+            abi.encode(targetInfo), KEEP_STATE());
+    }
+
+    //--- stake specific functions -------------------------------------//
+
+    function create(
+        NftId stakeNftId, 
+        IStaking.StakeInfo memory stakeInfo,
+        Amount stakeAmount
+    )
+        external
+    {
+        _create(
+            stakeNftId.toKey32(STAKE()),
+            abi.encode(stakeInfo));
+
+        _createBalance(stakeNftId, stakeAmount);
+    }
+
+    function update(
+        NftId stakeNftId, 
+        IStaking.StakeInfo memory stakeInfo
+    )
+        external
+    {
+        _update(
+            stakeNftId.toKey32(STAKE()),
+            abi.encode(stakeInfo),
+            KEEP_STATE());
+    }
+
+    //--- general functions --------------------------------------------//
+
+
+    function increaseBalance(NftId nftId, Amount amount, Amount rewardIncrementAmount)
+        external
+    {
+        Blocknumber lastUpdatedIn = _lastUpdatedIn[nftId];
+        bool updated = false;
+
+        if (lastUpdatedIn.eqz()) {
+            revert ErrorStakingStoreBalanceNotInitialized(nftId);
+        }
+
+        // update stake balance with amount
+        if(amount.gtz()) {
+            updated = true;
+            _stakeBalance[nftId] = _stakeBalance[nftId] + amount;
+            emit LogStakingStoreStakesIncreased(nftId, amount, _stakeBalance[nftId], lastUpdatedIn);
+        }
+
+        // update reward balance with amount
+        if(rewardIncrementAmount.gtz()) {
+            updated = true;
+            _rewardBalance[nftId] = _rewardBalance[nftId] + rewardIncrementAmount;
+            emit LogStakingStoreRewardsIncreased(nftId, rewardIncrementAmount, _rewardBalance[nftId], lastUpdatedIn);
+        }
+
+        if (updated) {
+            _lastUpdatedAt[nftId] = TimestampLib.blockTimestamp();
+            _lastUpdatedIn[nftId] = BlocknumberLib.currentBlocknumber();
+        }
+    }
+
+
+    function restakeRewards(
+        NftId nftId, 
+        Amount rewardIncrementAmount
+    )
+        external
+    {
+        Blocknumber lastUpdatedIn = _lastUpdatedIn[nftId];
+        Amount stakeAmount = _stakeBalance[nftId];
+        Amount rewardAmount = _rewardBalance[nftId];
+
+        if (lastUpdatedIn.eqz()) {
+            revert ErrorStakingStoreBalanceNotInitialized(nftId);
+        }
+
+        // move all rewards to stake balance
+        _stakeBalance[nftId] = stakeAmount + rewardAmount + rewardIncrementAmount;
+        _rewardBalance[nftId] = AmountLib.zero();
+
+        _lastUpdatedAt[nftId] = TimestampLib.blockTimestamp();
+        _lastUpdatedIn[nftId] = BlocknumberLib.currentBlocknumber();
+
+        emit LogStakingStoreRewardsRestaked(nftId, stakeAmount, rewardAmount, rewardIncrementAmount, _stakeBalance[nftId], lastUpdatedIn);
+    }
+
+
+    function updateRewards(
+        NftId nftId, 
+        Amount rewardIncrementAmount
+    )
+        external
+    {
+        Blocknumber lastUpdatedIn = _lastUpdatedIn[nftId];
+        Amount rewardAmount = _rewardBalance[nftId];
+
+        if (lastUpdatedIn.eqz()) {
+            revert ErrorStakingStoreBalanceNotInitialized(nftId);
+        }
+
+        // move all rewards to stake balance
+        _rewardBalance[nftId] = rewardAmount + rewardIncrementAmount;
+
+        _lastUpdatedAt[nftId] = TimestampLib.blockTimestamp();
+        _lastUpdatedIn[nftId] = BlocknumberLib.currentBlocknumber();
+
+        emit LogStakingStoreRewardsIncreased(nftId, rewardIncrementAmount, _rewardBalance[nftId], lastUpdatedIn);
+    }
+
+
+    function claimUpTo(
+        NftId nftId, 
+        Amount maxRewardAmount
+    )
+        external
+        returns (Amount rewardsClaimedAmount)
+    {
+        Blocknumber lastUpdatedIn = _lastUpdatedIn[nftId];
+        bool updated = false;
+
+        if (lastUpdatedIn.eqz()) {
+            revert ErrorStakingStoreBalanceNotInitialized(nftId);
+        }
+
+        // determine the claimable rewards amount
+        if (maxRewardAmount > _rewardBalance[nftId]) {
+            rewardsClaimedAmount = _rewardBalance[nftId];
+        } else {
+            rewardsClaimedAmount = maxRewardAmount;
+        }
+
+        // decrease reward amount
+        _rewardBalance[nftId] = _rewardBalance[nftId] - rewardsClaimedAmount;
+
+        _lastUpdatedAt[nftId] = TimestampLib.blockTimestamp();
+        _lastUpdatedIn[nftId] = BlocknumberLib.currentBlocknumber();
+
+        emit LogStakingStoreRewardsDecreased(nftId, rewardsClaimedAmount, _rewardBalance[nftId], lastUpdatedIn);
+    }
+
+
+    function unstakeUpTo(
+        NftId nftId, 
+        Amount maxUnstakeAmount,
+        Amount maxClaimAmount
+    )
+        external
+        returns (
+            Amount unstakedAmount,
+            Amount claimedAmount
+        )
+    {
+        Blocknumber lastUpdatedIn = _lastUpdatedIn[nftId];
+        bool updated = false;
+
+        if (lastUpdatedIn.eqz()) {
+            revert ErrorStakingStoreBalanceNotInitialized(nftId);
+        }
+
+        // determine the unstakeable amount
+        if (maxUnstakeAmount > _rewardBalance[nftId]) {
+            unstakedAmount = _rewardBalance[nftId];
+        } else {
+            unstakedAmount = maxUnstakeAmount;
+        }
+
+        // determine the claimable rewards amount
+        if (maxClaimAmount > _rewardBalance[nftId]) {
+            claimedAmount = _rewardBalance[nftId];
+        } else {
+            claimedAmount = maxClaimAmount;
+        }
+
+        // decrease amounts
+        _stakeBalance[nftId] = _stakeBalance[nftId] - unstakedAmount;
+        _rewardBalance[nftId] = _rewardBalance[nftId] - claimedAmount;
+
+        _lastUpdatedAt[nftId] = TimestampLib.blockTimestamp();
+        _lastUpdatedIn[nftId] = BlocknumberLib.currentBlocknumber();
+
+        emit LogStakingStoreStakesDecreased(nftId, unstakedAmount, _stakeBalance[nftId], lastUpdatedIn);
+        emit LogStakingStoreRewardsDecreased(nftId, claimedAmount, _rewardBalance[nftId], lastUpdatedIn);
+    }
+
+    //--- view functions -----------------------------------------------//
+
+    function getStakingReader() external view returns (StakingReader stakingReader){
+        return _reader;
+    }
+
+    function getTargetManager() external view returns (NftIdSetManager targetManager){
+        return _targetManager;
+    }
+
+    function exists(NftId stakeNftId) external view returns (bool) {
+        return exists(stakeNftId.toKey32(STAKE()));
+    }
+
+    function getStakeBalance(NftId nftId) external view returns (Amount balanceAmount) { return _stakeBalance[nftId]; }
+    function getRewardBalance(NftId nftId) external view returns (Amount rewardAmount) { return _rewardBalance[nftId]; }
+    function getBalanceUpdatedAt(NftId nftId) external view returns (Timestamp updatedAt) { return _lastUpdatedAt[nftId]; }
+
+    function getBalanceAndLastUpdatedAt(NftId nftId)
+        external
+        view
+        returns (
+            Amount stakeBalance,
+            Timestamp lastUpdatedAt
+        )
+    {
+        stakeBalance = _stakeBalance[nftId];
+        lastUpdatedAt = _lastUpdatedAt[nftId];
+    }
+
+    //--- private functions -------------------------------------------//
+
+    function _createBalance(NftId nftId, Amount amount) private {
+        if (_lastUpdatedIn[nftId].gtz()) {
+            revert ErrorStakingStoreBalanceAlreadyInitialized(nftId);
+        }
+
+        _stakeBalance[nftId] = amount;
+        _rewardBalance[nftId] = AmountLib.zero();
+
+        _lastUpdatedAt[nftId] = TimestampLib.blockTimestamp();
+        _lastUpdatedIn[nftId] = BlocknumberLib.currentBlocknumber();
+    }
+}

package/contracts/staking/TargetManagerLib.sol

@@ -0,0 +1,179 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+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 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/type/Amount.sol

@@ -0,0 +1,114 @@
+// 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
+} 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 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 _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

@@ -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,