Cryo Explorer Ethereum Mainnet

// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;

import "./interfaces/IBooster.sol";
import "./interfaces/IBoosterAdmin.sol";
import "./interfaces/IBoosterRewardManager.sol";
import "./interfaces/IRewards.sol";
import "./interfaces/IRewardHook.sol";
import "./interfaces/IPoolAddHook.sol";
import "./interfaces/IRewardHookExtended.sol";
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';

/*
    A Hook that forces harvests to happen once period finish is complete
*/
contract PoolHarvestHook is IRewardHook, IPoolAddHook{

    address public constant booster = address(0xF403C135812408BFbE8713b5A23a04b3D48AAE31);
    address public constant boosterOwner = address(0x256e1bbA846611C37CF89844a02435E6C098b86D);
    address public constant cvx = address(0x4e3FBD56CD56c3e72c1403e103b45Db9da5B9D2B);
    address public constant crv = address(0xD533a949740bb3306d119CC777fa900bA034cd52);
    address public immutable poolManager;
    address public immutable poolHook;
    address public immutable owner;

    mapping(address => bool) public operators;
    mapping(address => address) public stashMap;
    uint256 public timebuffer;

    bool private isOperator;

    event AddOperator(address indexed _op, bool _valid);
    event ChangeBuffer(uint256 _buffer);

    constructor(address _owner, address _poolManager, address _poolHook) public {
        owner = _owner;
        poolManager = _poolManager;
        poolHook = _poolHook;
        operators[msg.sender] = true;
        timebuffer = 1 hours;
        emit AddOperator(msg.sender, true);
    }

    modifier onlyOwner() {
        require(owner == msg.sender, "!owner");
        _;
    }

    modifier onlyOperator() {
        require(operators[msg.sender] || owner == msg.sender, "!op");
        _;
    }

    //set operator
    function setOperators(address _op, bool _valid) external onlyOwner{
        operators[_op] = _valid;
        emit AddOperator(_op, _valid);
    }

    //set time buffer
    function setBuffer(uint256 _seconds) external onlyOwner{
        timebuffer = _seconds;
        emit ChangeBuffer(_seconds);
    }

    //disable hook by removing all crv on this address
    function disable() external onlyOwner{
        IERC20(crv).transfer(address(0x1389388d01708118b497f59521f6943Be2541bb7), IERC20(crv).balanceOf(address(this)));
    }

    function setStashMap(uint256 _pid) public{
        //get stash address and crvrewards address
        (,,,address crvRewards, address stash,) = IBooster(booster).poolInfo(_pid);

        //add mapping stash -> rewards
        stashMap[stash] = crvRewards;
    }

    function setMultiStashMap(uint256[] calldata _pids) public{
        uint256 l = _pids.length;
        for(uint256 p = 0; p < l; ++p){
            //get stash address and crvrewards address
            (,,,address crvRewards, address stash,) = IBooster(booster).poolInfo(_pids[p]);

            //add mapping stash -> rewards
            stashMap[stash] = crvRewards;
        }
    }

    function poolAdded(address /*_gauge*/, uint256 /*_stashVersion*/, uint256 _poolId) external override{
        //require called from pool manager
        require(msg.sender == poolManager, "!poolMng");

        // set stash map
        setStashMap(_poolId);

        // tell booster owner reward manager to initialize pool (add cvx reward and stash hook)
        address rewardmanager = IBoosterAdmin(boosterOwner).stashRewardManager();
        IBoosterRewardManager(rewardmanager).initializePool(_poolId);
    }

    function earmarkRewards(uint256 _pid) external onlyOperator returns(bool){
        uint256 crvb = IERC20(crv).balanceOf(address(this));
        isOperator = true;
        IBooster(booster).earmarkRewards(_pid);
        isOperator = false;
        IERC20(crv).transfer(msg.sender, IERC20(crv).balanceOf(address(this))-crvb);
        return true;
    }

    //hook from stash
    function onRewardClaim() external override{
        //msg.sender is a proper stash if in the stash map
        _onHarvest(stashMap[msg.sender]);
    }

    //hook from PoolRewardHook
    function getReward(address _stash) public{
        require(msg.sender == poolHook, "!hook");
        //can trust the stash address given by PoolRewardHook
        _onHarvest(stashMap[_stash]);
    }

    function _onHarvest(address _crvRewards) internal{

        //if not set or operator, return
        if(_crvRewards == address(0) || isOperator){
            return;
        }

        //check period finish on crvrewards
        if (block.timestamp >= IRewards(_crvRewards).periodFinish()+timebuffer) {
            return;
        }

        // //check if there is more crv rewards waiting to be claimed than the current reward epoch
        uint256 currentRewards = IRewards(_crvRewards).currentRewards();
        uint256 balanceOnBooster = IERC20(crv).balanceOf(booster);
        if(balanceOnBooster > currentRewards * 2){
            return;
        }

        //if fail, send 1 wei of crv to booster
        IERC20(crv).transfer(booster, 1);
    }

}

// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;

interface IBooster {
    function owner() external view returns(address);
    function feeToken() external view returns(address);
    function feeDistro() external view returns(address);
    function lockFees() external view returns(address);
    function stakerRewards() external view returns(address);
    function lockRewards() external view returns(address);
    function setVoteDelegate(address _voteDelegate) external;
    function vote(uint256 _voteId, address _votingAddress, bool _support) external returns(bool);
    function voteGaugeWeight(address[] calldata _gauge, uint256[] calldata _weight ) external returns(bool);
    function poolInfo(uint256 _pid) external view returns(address _lptoken, address _token, address _gauge, address _crvRewards, address _stash, bool _shutdown);
    function earmarkRewards(uint256 _pid) external returns(bool);
    function earmarkFees() external returns(bool);
    function isShutdown() external view returns(bool);
    function poolLength() external view returns (uint256);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;

interface IRewards{
    function stake(address, uint256) external;
    function stakeFor(address, uint256) external;
    function withdraw(address, uint256) external;
    function setWeight(address _pool, uint256 _amount) external returns(bool);
    function setWeights(address[] calldata _account, uint256[] calldata _amount) external;
    function setDistributor(address _distro, bool _valid) external;
    function getReward(address) external;
    function queueNewRewards(uint256) external;
    function addExtraReward(address) external;
    function setRewardHook(address) external;
    function user_checkpoint(address _account) external returns(bool);
    function periodFinish() external view returns(uint256);
    function currentRewards() external view returns(uint256);
    function rewardToken() external view returns(address);
    function rewardMap(address) external view returns(bool);
    function earned(address account) external view returns (uint256);
}

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

interface IRewardHook {
    function onRewardClaim() external;
}

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

interface IPoolAddHook {
    function poolAdded(address _gauge, uint256 _stashVersion, uint256 _poolId) external;
}

// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;

interface IBoosterAdmin {
    function owner() external view returns(address);
    function stashRewardManager() external view returns(address);
    function setStashRewardManager(address _mng) external;
    function acceptStashRewardManager() external;
    function setStashExtraReward(uint256 _pid, address _token) external;
    function setStashRewardHook(uint256 _pid, address _hook) external;
    function setStashTokenIsValid(address stashToken, bool isValid) external;
}

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

interface IRewardHookExtended {
    function onRewardClaim() external;
    function poolRewardLength(address _pool) external view returns(uint256);
    function poolRewardList(address _pool, uint256 _index) external view returns(address _rewardContract);
    function addPoolReward(address _pool, address _rewardContract) external;
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;

interface IBoosterRewardManager {
    function defaultHook() external view returns(address);
    function initializePool(uint256 _pid) external;
    function setStashRewardManager(address _mng) external;
    function setStashExtraReward(uint256 _pid, address _token) external;
    function setStashRewardHook(uint256 _pid, address _hook) external;
    function setMultiStashRewardHook(uint256[] calldata _pids, address _hook) external;
    function setStashTokenIsValid(address stashToken, bool isValid) external;
}