@rarible/external-contracts 3.11.4

package/contracts/extension/Staking721.sol

@@ -0,0 +1,362 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.11;
+
+/// @author thirdweb
+
+import "../external-deps/openzeppelin/security/ReentrancyGuard.sol";
+import "../external-deps/openzeppelin/utils/math/SafeMath.sol";
+import "../eip/interface/IERC721.sol";
+
+import "./interface/IStaking721.sol";
+
+abstract contract Staking721 is ReentrancyGuard, IStaking721 {
+    /*///////////////////////////////////////////////////////////////
+                            State variables / Mappings
+    //////////////////////////////////////////////////////////////*/
+
+    ///@dev Address of ERC721 NFT contract -- staked tokens belong to this contract.
+    address public immutable stakingToken;
+
+    /// @dev Flag to check direct transfers of staking tokens.
+    uint8 internal isStaking = 1;
+
+    ///@dev Next staking condition Id. Tracks number of conditon updates so far.
+    uint64 private nextConditionId;
+
+    ///@dev List of token-ids ever staked.
+    uint256[] public indexedTokens;
+
+    /// @dev List of accounts that have staked their NFTs.
+    address[] public stakersArray;
+
+    ///@dev Mapping from token-id to whether it is indexed or not.
+    mapping(uint256 => bool) public isIndexed;
+
+    ///@dev Mapping from staker address to Staker struct. See {struct IStaking721.Staker}.
+    mapping(address => Staker) public stakers;
+
+    /// @dev Mapping from staked token-id to staker address.
+    mapping(uint256 => address) public stakerAddress;
+
+    ///@dev Mapping from condition Id to staking condition. See {struct IStaking721.StakingCondition}
+    mapping(uint256 => StakingCondition) private stakingConditions;
+
+    constructor(address _stakingToken) ReentrancyGuard() {
+        require(address(_stakingToken) != address(0), "collection address 0");
+        stakingToken = _stakingToken;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        External/Public Functions
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     *  @notice    Stake ERC721 Tokens.
+     *
+     *  @dev       See {_stake}. Override that to implement custom logic.
+     *
+     *  @param _tokenIds    List of tokens to stake.
+     */
+    function stake(uint256[] calldata _tokenIds) external nonReentrant {
+        _stake(_tokenIds);
+    }
+
+    /**
+     *  @notice    Withdraw staked tokens.
+     *
+     *  @dev       See {_withdraw}. Override that to implement custom logic.
+     *
+     *  @param _tokenIds    List of tokens to withdraw.
+     */
+    function withdraw(uint256[] calldata _tokenIds) external nonReentrant {
+        _withdraw(_tokenIds);
+    }
+
+    /**
+     *  @notice    Claim accumulated rewards.
+     *
+     *  @dev       See {_claimRewards}. Override that to implement custom logic.
+     *             See {_calculateRewards} for reward-calculation logic.
+     */
+    function claimRewards() external nonReentrant {
+        _claimRewards();
+    }
+
+    /**
+     *  @notice  Set time unit. Set as a number of seconds.
+     *           Could be specified as -- x * 1 hours, x * 1 days, etc.
+     *
+     *  @dev     Only admin/authorized-account can call it.
+     *
+     *
+     *  @param _timeUnit    New time unit.
+     */
+    function setTimeUnit(uint256 _timeUnit) external virtual {
+        if (!_canSetStakeConditions()) {
+            revert("Not authorized");
+        }
+
+        StakingCondition memory condition = stakingConditions[nextConditionId - 1];
+        require(_timeUnit != condition.timeUnit, "Time-unit unchanged.");
+
+        _setStakingCondition(_timeUnit, condition.rewardsPerUnitTime);
+
+        emit UpdatedTimeUnit(condition.timeUnit, _timeUnit);
+    }
+
+    /**
+     *  @notice  Set rewards per unit of time.
+     *           Interpreted as x rewards per second/per day/etc based on time-unit.
+     *
+     *  @dev     Only admin/authorized-account can call it.
+     *
+     *
+     *  @param _rewardsPerUnitTime    New rewards per unit time.
+     */
+    function setRewardsPerUnitTime(uint256 _rewardsPerUnitTime) external virtual {
+        if (!_canSetStakeConditions()) {
+            revert("Not authorized");
+        }
+
+        StakingCondition memory condition = stakingConditions[nextConditionId - 1];
+        require(_rewardsPerUnitTime != condition.rewardsPerUnitTime, "Reward unchanged.");
+
+        _setStakingCondition(condition.timeUnit, _rewardsPerUnitTime);
+
+        emit UpdatedRewardsPerUnitTime(condition.rewardsPerUnitTime, _rewardsPerUnitTime);
+    }
+
+    /**
+     *  @notice View amount staked and total rewards for a user.
+     *
+     *  @param _staker          Address for which to calculated rewards.
+     *  @return _tokensStaked   List of token-ids staked by staker.
+     *  @return _rewards        Available reward amount.
+     */
+    function getStakeInfo(
+        address _staker
+    ) external view virtual returns (uint256[] memory _tokensStaked, uint256 _rewards) {
+        uint256[] memory _indexedTokens = indexedTokens;
+        bool[] memory _isStakerToken = new bool[](_indexedTokens.length);
+        uint256 indexedTokenCount = _indexedTokens.length;
+        uint256 stakerTokenCount = 0;
+
+        for (uint256 i = 0; i < indexedTokenCount; i++) {
+            _isStakerToken[i] = stakerAddress[_indexedTokens[i]] == _staker;
+            if (_isStakerToken[i]) stakerTokenCount += 1;
+        }
+
+        _tokensStaked = new uint256[](stakerTokenCount);
+        uint256 count = 0;
+        for (uint256 i = 0; i < indexedTokenCount; i++) {
+            if (_isStakerToken[i]) {
+                _tokensStaked[count] = _indexedTokens[i];
+                count += 1;
+            }
+        }
+
+        _rewards = _availableRewards(_staker);
+    }
+
+    function getTimeUnit() public view returns (uint256 _timeUnit) {
+        _timeUnit = stakingConditions[nextConditionId - 1].timeUnit;
+    }
+
+    function getRewardsPerUnitTime() public view returns (uint256 _rewardsPerUnitTime) {
+        _rewardsPerUnitTime = stakingConditions[nextConditionId - 1].rewardsPerUnitTime;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                            Internal Functions
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev Staking logic. Override to add custom logic.
+    function _stake(uint256[] calldata _tokenIds) internal virtual {
+        uint64 len = uint64(_tokenIds.length);
+        require(len != 0, "Staking 0 tokens");
+
+        address _stakingToken = stakingToken;
+
+        if (stakers[_stakeMsgSender()].amountStaked > 0) {
+            _updateUnclaimedRewardsForStaker(_stakeMsgSender());
+        } else {
+            stakersArray.push(_stakeMsgSender());
+            stakers[_stakeMsgSender()].timeOfLastUpdate = uint128(block.timestamp);
+            stakers[_stakeMsgSender()].conditionIdOflastUpdate = nextConditionId - 1;
+        }
+        for (uint256 i = 0; i < len; ++i) {
+            isStaking = 2;
+            IERC721(_stakingToken).safeTransferFrom(_stakeMsgSender(), address(this), _tokenIds[i]);
+            isStaking = 1;
+
+            stakerAddress[_tokenIds[i]] = _stakeMsgSender();
+
+            if (!isIndexed[_tokenIds[i]]) {
+                isIndexed[_tokenIds[i]] = true;
+                indexedTokens.push(_tokenIds[i]);
+            }
+        }
+        stakers[_stakeMsgSender()].amountStaked += len;
+
+        emit TokensStaked(_stakeMsgSender(), _tokenIds);
+    }
+
+    /// @dev Withdraw logic. Override to add custom logic.
+    function _withdraw(uint256[] calldata _tokenIds) internal virtual {
+        uint256 _amountStaked = stakers[_stakeMsgSender()].amountStaked;
+        uint64 len = uint64(_tokenIds.length);
+        require(len != 0, "Withdrawing 0 tokens");
+        require(_amountStaked >= len, "Withdrawing more than staked");
+
+        address _stakingToken = stakingToken;
+
+        _updateUnclaimedRewardsForStaker(_stakeMsgSender());
+
+        if (_amountStaked == len) {
+            address[] memory _stakersArray = stakersArray;
+            for (uint256 i = 0; i < _stakersArray.length; ++i) {
+                if (_stakersArray[i] == _stakeMsgSender()) {
+                    stakersArray[i] = _stakersArray[_stakersArray.length - 1];
+                    stakersArray.pop();
+                    break;
+                }
+            }
+        }
+        stakers[_stakeMsgSender()].amountStaked -= len;
+
+        for (uint256 i = 0; i < len; ++i) {
+            require(stakerAddress[_tokenIds[i]] == _stakeMsgSender(), "Not staker");
+            stakerAddress[_tokenIds[i]] = address(0);
+            IERC721(_stakingToken).safeTransferFrom(address(this), _stakeMsgSender(), _tokenIds[i]);
+        }
+
+        emit TokensWithdrawn(_stakeMsgSender(), _tokenIds);
+    }
+
+    /// @dev Logic for claiming rewards. Override to add custom logic.
+    function _claimRewards() internal virtual {
+        uint256 rewards = stakers[_stakeMsgSender()].unclaimedRewards + _calculateRewards(_stakeMsgSender());
+
+        require(rewards != 0, "No rewards");
+
+        stakers[_stakeMsgSender()].timeOfLastUpdate = uint128(block.timestamp);
+        stakers[_stakeMsgSender()].unclaimedRewards = 0;
+        stakers[_stakeMsgSender()].conditionIdOflastUpdate = nextConditionId - 1;
+
+        _mintRewards(_stakeMsgSender(), rewards);
+
+        emit RewardsClaimed(_stakeMsgSender(), rewards);
+    }
+
+    /// @dev View available rewards for a user.
+    function _availableRewards(address _user) internal view virtual returns (uint256 _rewards) {
+        if (stakers[_user].amountStaked == 0) {
+            _rewards = stakers[_user].unclaimedRewards;
+        } else {
+            _rewards = stakers[_user].unclaimedRewards + _calculateRewards(_user);
+        }
+    }
+
+    /// @dev Update unclaimed rewards for a users. Called for every state change for a user.
+    function _updateUnclaimedRewardsForStaker(address _staker) internal virtual {
+        uint256 rewards = _calculateRewards(_staker);
+        stakers[_staker].unclaimedRewards += rewards;
+        stakers[_staker].timeOfLastUpdate = uint128(block.timestamp);
+        stakers[_staker].conditionIdOflastUpdate = nextConditionId - 1;
+    }
+
+    /// @dev Set staking conditions.
+    function _setStakingCondition(uint256 _timeUnit, uint256 _rewardsPerUnitTime) internal virtual {
+        require(_timeUnit != 0, "time-unit can't be 0");
+        uint256 conditionId = nextConditionId;
+        nextConditionId += 1;
+
+        stakingConditions[conditionId] = StakingCondition({
+            timeUnit: _timeUnit,
+            rewardsPerUnitTime: _rewardsPerUnitTime,
+            startTimestamp: block.timestamp,
+            endTimestamp: 0
+        });
+
+        if (conditionId > 0) {
+            stakingConditions[conditionId - 1].endTimestamp = block.timestamp;
+        }
+    }
+
+    /// @dev Calculate rewards for a staker.
+    function _calculateRewards(address _staker) internal view virtual returns (uint256 _rewards) {
+        Staker memory staker = stakers[_staker];
+
+        uint256 _stakerConditionId = staker.conditionIdOflastUpdate;
+        uint256 _nextConditionId = nextConditionId;
+
+        for (uint256 i = _stakerConditionId; i < _nextConditionId; i += 1) {
+            StakingCondition memory condition = stakingConditions[i];
+
+            uint256 startTime = i != _stakerConditionId ? condition.startTimestamp : staker.timeOfLastUpdate;
+            uint256 endTime = condition.endTimestamp != 0 ? condition.endTimestamp : block.timestamp;
+
+            (bool noOverflowProduct, uint256 rewardsProduct) = SafeMath.tryMul(
+                (endTime - startTime) * staker.amountStaked,
+                condition.rewardsPerUnitTime
+            );
+            (bool noOverflowSum, uint256 rewardsSum) = SafeMath.tryAdd(_rewards, rewardsProduct / condition.timeUnit);
+
+            _rewards = noOverflowProduct && noOverflowSum ? rewardsSum : _rewards;
+        }
+    }
+
+    /*////////////////////////////////////////////////////////////////////
+        Optional hooks that can be implemented in the derived contract
+    ///////////////////////////////////////////////////////////////////*/
+
+    /// @dev Exposes the ability to override the msg sender -- support ERC2771.
+    function _stakeMsgSender() internal virtual returns (address) {
+        return msg.sender;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+        Virtual functions to be implemented in derived contract
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     *  @notice View total rewards available in the staking contract.
+     *
+     */
+    function getRewardTokenBalance() external view virtual returns (uint256 _rewardsAvailableInContract);
+
+    /**
+     *  @dev    Mint/Transfer ERC20 rewards to the staker. Must override.
+     *
+     *  @param _staker    Address for which to calculated rewards.
+     *  @param _rewards   Amount of tokens to be given out as reward.
+     *
+     *  For example, override as below to mint ERC20 rewards:
+     *
+     * ```
+     *  function _mintRewards(address _staker, uint256 _rewards) internal override {
+     *
+     *      TokenERC20(rewardTokenAddress).mintTo(_staker, _rewards);
+     *
+     *  }
+     * ```
+     */
+    function _mintRewards(address _staker, uint256 _rewards) internal virtual;
+
+    /**
+     *  @dev    Returns whether staking restrictions can be set in given execution context.
+     *          Must override.
+     *
+     *
+     *  For example, override as below to restrict access to admin:
+     *
+     * ```
+     *  function _canSetStakeConditions() internal override {
+     *
+     *      return msg.sender == adminAddress;
+     *
+     *  }
+     * ```
+     */
+    function _canSetStakeConditions() internal view virtual returns (bool);
+}