{
    "Function": "slitherConstructorConstantVariables",
    "File": "contracts/Booster.sol",
    "Parent Contracts": [],
    "High-Level Calls": [],
    "Internal Calls": [],
    "Library Calls": [],
    "Low-Level Calls": [],
    "Code": "contract Booster {\n    using SafeERC20 for IERC20;\n    using Address for address;\n    using SafeMath for uint256;\n\n    // ve3Token reward pool\n    uint256 public lockIncentive = 1000; //incentive to veAsset stakers\n    // veToken reward pool\n    uint256 public stakerIncentive = 450; //incentive to native token stakers\n    // veToken locking reward pool xVE3D\n    uint256 public stakerLockIncentive;\n    // caller reward\n    uint256 public earmarkIncentive = 50; //incentive to users who spend gas to make calls\n    // platoform fee\n    uint256 public platformFee; //possible fee to build treasury\n    uint256 public constant MaxFees = 2000;\n    uint256 public constant FEE_DENOMINATOR = 10000;\n\n    uint256 public lockFeesIncentive = 10000; //ve3Token veVeAsset fees percentage\n    uint256 public stakerLockFeesIncentive; //xVE3D veVeAsset fees percentage\n\n    address public owner;\n    address public feeManager;\n    address public poolManager;\n    address public immutable staker;\n    address public immutable minter;\n    address public immutable veAsset;\n    address public immutable feeDistro;\n    address public rewardFactory;\n    address public stashFactory;\n    address public tokenFactory;\n    address public rewardArbitrator;\n    address public voteDelegate;\n    address public treasury;\n    address public stakerRewards; //vetoken rewards\n    address public stakerLockRewards; // veToken lock rewards xVE3D\n    address public lockRewards; //ve3Token rewards(veAsset)\n    address public lockFees; //ve3Token veVeAsset fees\n    address public feeToken;\n\n    bool public isShutdown;\n\n    struct PoolInfo {\n        address lptoken;\n        address token;\n        address gauge;\n        address veAssetRewards;\n        address stash;\n        bool shutdown;\n    }\n\n    //index(pid) -> pool\n    PoolInfo[] public poolInfo;\n    mapping(address => bool) public gaugeMap;\n\n    event Deposited(address indexed user, uint256 indexed poolid, uint256 amount);\n    event Withdrawn(address indexed user, uint256 indexed poolid, uint256 amount);\n    event OwnerUpdated(address indexed owner);\n    event FeeManagerUpdated(address indexed feeM);\n    event PoolManagerUpdated(address indexed poolM);\n    event FactoriesUpdated(address indexed rfactory, address indexed tfactory);\n    event ArbitratorUpdated(address indexed arb);\n    event VoteDelegateUpdated(address indexed voteDelegate);\n    event RewardContractsUpdated(\n        address indexed rewards,\n        address indexed stakerRewards,\n        address indexed stakerLockRewards\n    );\n    event FeesUpdated(\n        uint256 lockFees,\n        uint256 stakerFees,\n        uint256 stakerLockFee,\n        uint256 callerFees,\n        uint256 platform\n    );\n    event TreasuryUpdated(address indexed treasury);\n    event PoolAdded(\n        address indexed lptoken,\n        address indexed gauge,\n        address indexed token,\n        address rewardPool\n    );\n    event PoolShuttedDown(uint256 indexed pid);\n    event SystemShuttedDown();\n    event Voted(uint256 indexed voteId, address indexed votingAddress, bool support);\n\n    constructor(\n        address _staker,\n        address _minter,\n        address _veAsset,\n        address _feeDistro\n    ) {\n        isShutdown = false;\n        staker = _staker;\n        owner = msg.sender;\n        voteDelegate = msg.sender;\n        feeManager = msg.sender;\n        poolManager = msg.sender;\n        minter = _minter;\n        veAsset = _veAsset;\n        feeDistro = _feeDistro;\n    }\n\n    /// SETTER SECTION ///\n\n    function setOwner(address _owner) external {\n        require(msg.sender == owner, \"!auth\");\n        owner = _owner;\n        emit OwnerUpdated(_owner);\n    }\n\n    function setFeeManager(address _feeM) external {\n        require(msg.sender == feeManager, \"!auth\");\n        feeManager = _feeM;\n        emit FeeManagerUpdated(_feeM);\n    }\n\n    function setPoolManager(address _poolM) external {\n        require(msg.sender == poolManager, \"!auth\");\n        poolManager = _poolM;\n        emit PoolManagerUpdated(_poolM);\n    }\n\n    function setFactories(\n        address _rfactory,\n        address _sfactory,\n        address _tfactory\n    ) external {\n        require(msg.sender == owner, \"!auth\");\n\n        //reward factory only allow this to be called once even if owner\n        //removes ability to inject malicious staking contracts\n        //token factory can also be immutable\n        if (rewardFactory == address(0)) {\n            rewardFactory = _rfactory;\n            tokenFactory = _tfactory;\n            emit FactoriesUpdated(_rfactory, _tfactory);\n        }\n\n        //stash factory should be considered more safe to change\n        //updating may be required to handle new types of gauges\n        stashFactory = _sfactory;\n    }\n\n    function setArbitrator(address _arb) external {\n        require(msg.sender == owner, \"!auth\");\n        rewardArbitrator = _arb;\n        emit ArbitratorUpdated(_arb);\n    }\n\n    function setVoteDelegate(address _voteDelegate) external {\n        require(msg.sender == voteDelegate, \"!auth\");\n        voteDelegate = _voteDelegate;\n        emit VoteDelegateUpdated(_voteDelegate);\n    }\n\n    function setRewardContracts(\n        address _rewards,\n        address _stakerRewards,\n        address _stakerLockRewards\n    ) external {\n        require(msg.sender == owner, \"!auth\");\n\n        //reward contracts are immutable or else the owner\n        //has a means to redeploy and mint cvx via rewardClaimed()\n        if (lockRewards == address(0)) {\n            lockRewards = _rewards;\n            stakerRewards = _stakerRewards;\n            stakerLockRewards = _stakerLockRewards;\n        }\n\n        emit RewardContractsUpdated(_rewards, _stakerRewards, _stakerLockRewards);\n    }\n\n    // Set reward token and claim contract, get from Curve's registry\n    function setFeeInfo(uint256 _lockFeesIncentive, uint256 _stakerLockFeesIncentive) external {\n        require(msg.sender == feeManager, \"!auth\");\n\n        lockFeesIncentive = _lockFeesIncentive;\n        stakerLockFeesIncentive = _stakerLockFeesIncentive;\n\n        address _feeToken = IFeeDistro(feeDistro).token();\n        if (feeToken != _feeToken) {\n            //create a new reward contract for the new token\n            lockFees = IRewardFactory(rewardFactory).CreateTokenRewards(_feeToken, lockRewards);\n\n            if (_feeToken != veAsset) {\n                IRewards(stakerLockRewards).addReward(\n                    _feeToken,\n                    address(0),\n                    address(0),\n                    address(0),\n                    address(this),\n                    false\n                );\n            }\n\n            feeToken = _feeToken;\n        }\n    }\n\n    function setFees(\n        uint256 _lockFees,\n        uint256 _stakerFees,\n        uint256 _stakerLockIncentiveFee,\n        uint256 _callerFees,\n        uint256 _platform\n    ) external {\n        require(msg.sender == feeManager, \"!auth\");\n\n        uint256 total = _lockFees.add(_stakerFees).add(_callerFees).add(_platform).add(\n            _stakerLockIncentiveFee\n        );\n        require(total <= MaxFees, \">MaxFees\");\n\n        //values must be within certain ranges\n\n        lockIncentive = _lockFees;\n        stakerIncentive = _stakerFees;\n        stakerLockIncentive = _stakerLockIncentiveFee;\n        earmarkIncentive = _callerFees;\n        platformFee = _platform;\n        emit FeesUpdated(_lockFees, _stakerFees, _stakerLockIncentiveFee, _callerFees, _platform);\n    }\n\n    function setTreasury(address _treasury) external {\n        require(msg.sender == feeManager, \"!auth\");\n        treasury = _treasury;\n        emit TreasuryUpdated(_treasury);\n    }\n\n    /// END SETTER SECTION ///\n\n    function poolLength() external view returns (uint256) {\n        return poolInfo.length;\n    }\n\n    //create a new pool\n    function addPool(\n        address _lptoken,\n        address _gauge,\n        uint256 _stashVersion\n    ) external returns (bool) {\n        require(msg.sender == poolManager && !isShutdown, \"!add\");\n        require(_gauge != address(0) && _lptoken != address(0), \"!param\");\n\n        //the next pool's pid\n        uint256 pid = poolInfo.length;\n\n        //create a tokenized deposit\n        address token = ITokenFactory(tokenFactory).CreateDepositToken(_lptoken);\n        //create a reward contract for veAsset rewards\n        address newRewardPool = IRewardFactory(rewardFactory).CreateVeAssetRewards(pid, token);\n\n        //create a stash to handle extra incentives\n        address stash = IStashFactory(stashFactory).CreateStash(\n            pid,\n            veAsset,\n            _gauge,\n            staker,\n            _stashVersion\n        );\n\n        //add the new pool\n        poolInfo.push(\n            PoolInfo({\n                lptoken: _lptoken,\n                token: token,\n                gauge: _gauge,\n                veAssetRewards: newRewardPool,\n                stash: stash,\n                shutdown: false\n            })\n        );\n        gaugeMap[_gauge] = true;\n\n        //give stashes access to rewardfactory and voteproxy\n        //   voteproxy so it can grab the incentive tokens off the contract after claiming rewards\n        //   reward factory so that stashes can make new extra reward contracts if a new incentive is added to the gauge\n        if (stash != address(0)) {\n            poolInfo[pid].stash = stash;\n            IStaker(staker).setStashAccess(stash, true);\n            IRewardFactory(rewardFactory).setAccess(stash, true);\n        }\n        emit PoolAdded(_lptoken, _gauge, token, newRewardPool);\n\n        return true;\n    }\n\n    //shutdown pool\n    function shutdownPool(uint256 _pid) external returns (bool) {\n        require(msg.sender == poolManager, \"!auth\");\n        PoolInfo storage pool = poolInfo[_pid];\n\n        //withdraw from gauge\n        try IStaker(staker).withdrawAll(pool.lptoken, pool.gauge) {} catch {}\n\n        pool.shutdown = true;\n        gaugeMap[pool.gauge] = false;\n\n        emit PoolShuttedDown(_pid);\n        return true;\n    }\n\n    //shutdown this contract.\n    //  unstake and pull all lp tokens to this address\n    //  only allow withdrawals\n    function shutdownSystem() external {\n        require(msg.sender == owner, \"!auth\");\n        isShutdown = true;\n\n        for (uint256 i = 0; i < poolInfo.length; i++) {\n            PoolInfo storage pool = poolInfo[i];\n            if (pool.shutdown) continue;\n\n            address token = pool.lptoken;\n            address gauge = pool.gauge;\n\n            //withdraw from gauge\n            try IStaker(staker).withdrawAll(token, gauge) {\n                pool.shutdown = true;\n            } catch {}\n        }\n        emit SystemShuttedDown();\n    }\n\n    //deposit lp tokens and stake\n    function deposit(\n        uint256 _pid,\n        uint256 _amount,\n        bool _stake\n    ) public returns (bool) {\n        require(!isShutdown, \"shutdown\");\n        PoolInfo storage pool = poolInfo[_pid];\n        require(pool.shutdown == false, \"pool is closed\");\n\n        //send to proxy to stake\n        address lptoken = pool.lptoken;\n        IERC20(lptoken).safeTransferFrom(msg.sender, staker, _amount);\n\n        //stake\n        address gauge = pool.gauge;\n        require(gauge != address(0), \"!gauge setting\");\n        IStaker(staker).deposit(lptoken, gauge);\n\n        //some gauges claim rewards when depositing, stash them in a seperate contract until next claim\n        address stash = pool.stash;\n        if (stash != address(0)) {\n            IStash(stash).stashRewards();\n        }\n\n        address token = pool.token;\n        if (_stake) {\n            //mint here and send to rewards on user behalf\n            ITokenMinter(token).mint(address(this), _amount);\n            address rewardContract = pool.veAssetRewards;\n            IERC20(token).safeApprove(rewardContract, _amount);\n            IRewards(rewardContract).stakeFor(msg.sender, _amount);\n        } else {\n            //add user balance directly\n            ITokenMinter(token).mint(msg.sender, _amount);\n        }\n\n        emit Deposited(msg.sender, _pid, _amount);\n        return true;\n    }\n\n    //deposit all lp tokens and stake\n    function depositAll(uint256 _pid, bool _stake) external returns (bool) {\n        address lptoken = poolInfo[_pid].lptoken;\n        uint256 balance = IERC20(lptoken).balanceOf(msg.sender);\n        deposit(_pid, balance, _stake);\n        return true;\n    }\n\n    //withdraw lp tokens\n    function _withdraw(\n        uint256 _pid,\n        uint256 _amount,\n        address _from,\n        address _to\n    ) internal {\n        PoolInfo storage pool = poolInfo[_pid];\n        address lptoken = pool.lptoken;\n        address gauge = pool.gauge;\n\n        //remove lp balance\n        address token = pool.token;\n        ITokenMinter(token).burn(_from, _amount);\n\n        //pull from gauge if not shutdown\n        // if shutdown tokens will be in this contract\n        if (!pool.shutdown) {\n            IStaker(staker).withdraw(lptoken, gauge, _amount);\n        }\n\n        //some gauges claim rewards when withdrawing, stash them in a seperate contract until next claim\n        //do not call if shutdown since stashes wont have access\n        address stash = pool.stash;\n        if (stash != address(0) && !isShutdown && !pool.shutdown) {\n            IStash(stash).stashRewards();\n        }\n\n        //return lp tokens\n        IERC20(lptoken).safeTransfer(_to, _amount);\n\n        emit Withdrawn(_to, _pid, _amount);\n    }\n\n    //withdraw lp tokens\n    function withdraw(uint256 _pid, uint256 _amount) public returns (bool) {\n        _withdraw(_pid, _amount, msg.sender, msg.sender);\n        return true;\n    }\n\n    //withdraw all lp tokens\n    function withdrawAll(uint256 _pid) public returns (bool) {\n        address token = poolInfo[_pid].token;\n        uint256 userBal = IERC20(token).balanceOf(msg.sender);\n        withdraw(_pid, userBal);\n        return true;\n    }\n\n    //allow reward contracts to send here and withdraw to user\n    function withdrawTo(\n        uint256 _pid,\n        uint256 _amount,\n        address _to\n    ) external returns (bool) {\n        address rewardContract = poolInfo[_pid].veAssetRewards;\n        require(msg.sender == rewardContract, \"!auth\");\n\n        _withdraw(_pid, _amount, msg.sender, _to);\n        return true;\n    }\n\n    /**\n     * @notice set valid vote hash on VoterProxy\n     */\n    function setVote(bytes32 _hash, bool valid) external returns (bool) {\n        require(msg.sender == voteDelegate, \"!auth\");\n\n        IStaker(staker).setVote(_hash, valid);\n        return true;\n    }\n\n    function voteGaugeWeight(address[] calldata _gauge, uint256[] calldata _weight)\n        external\n        returns (bool)\n    {\n        require(msg.sender == voteDelegate, \"!auth\");\n\n        IStaker(staker).voteGaugeWeight(_gauge, _weight);\n\n        return true;\n    }\n\n    function claimRewards(uint256 _pid, address _gauge) external returns (bool) {\n        address stash = poolInfo[_pid].stash;\n        require(msg.sender == stash, \"!auth\");\n\n        IStaker(staker).claimRewards(_gauge);\n        return true;\n    }\n\n    function setGaugeRedirect(uint256 _pid) external returns (bool) {\n        address stash = poolInfo[_pid].stash;\n        require(msg.sender == stash, \"!auth\");\n        address gauge = poolInfo[_pid].gauge;\n        bytes memory data = abi.encodeWithSelector(\n            bytes4(keccak256(\"set_rewards_receiver(address)\")),\n            stash\n        );\n        IStaker(staker).execute(gauge, uint256(0), data);\n        return true;\n    }\n\n    //claim veAsset and extra rewards and disperse to reward contracts\n    function _earmarkRewards(uint256 _pid) internal {\n        PoolInfo storage pool = poolInfo[_pid];\n        require(pool.shutdown == false, \"pool is closed\");\n\n        address gauge = pool.gauge;\n\n        //claim veAsset\n        IStaker(staker).claimVeAsset(gauge);\n\n        //check if there are extra rewards\n        address stash = pool.stash;\n        if (stash != address(0)) {\n            //claim extra rewards\n            IStash(stash).claimRewards();\n            //process extra rewards\n            IStash(stash).processStash();\n        }\n\n        //veAsset balance\n        uint256 veAssetBal = IERC20(veAsset).balanceOf(address(this));\n\n        if (veAssetBal > 0) {\n            uint256 _lockIncentive = veAssetBal.mul(lockIncentive).div(FEE_DENOMINATOR);\n            uint256 _stakerIncentive = veAssetBal.mul(stakerIncentive).div(FEE_DENOMINATOR);\n            uint256 _stakerLockIncentive = veAssetBal.mul(stakerLockIncentive).div(\n                FEE_DENOMINATOR\n            );\n            uint256 _callIncentive = veAssetBal.mul(earmarkIncentive).div(FEE_DENOMINATOR);\n\n            //send treasury\n            if (treasury != address(0) && treasury != address(this) && platformFee > 0) {\n                //only subtract after address condition check\n                uint256 _platform = veAssetBal.mul(platformFee).div(FEE_DENOMINATOR);\n                veAssetBal = veAssetBal.sub(_platform);\n                IERC20(veAsset).safeTransfer(treasury, _platform);\n            }\n\n            //remove incentives from balance\n            veAssetBal = veAssetBal\n                .sub(_lockIncentive)\n                .sub(_callIncentive)\n                .sub(_stakerIncentive)\n                .sub(_stakerLockIncentive);\n\n            //send incentives for calling\n            if (_callIncentive > 0) {\n                IERC20(veAsset).safeTransfer(msg.sender, _callIncentive);\n            }\n\n            //send veAsset to lp provider reward contract\n            address rewardContract = pool.veAssetRewards;\n            IERC20(veAsset).safeTransfer(rewardContract, veAssetBal);\n            IRewards(rewardContract).queueNewRewards(veAssetBal);\n\n            //send lockers' share of veAsset to reward contract\n            if (_lockIncentive > 0) {\n                IERC20(veAsset).safeTransfer(lockRewards, _lockIncentive);\n                IRewards(lockRewards).queueNewRewards(_lockIncentive);\n            }\n            //send stakers's share of veAsset to VE3D reward contract\n            if (_stakerIncentive > 0) {\n                IERC20(veAsset).safeTransfer(stakerRewards, _stakerIncentive);\n                IRewards(stakerRewards).queueNewRewards(veAsset, _stakerIncentive);\n            }\n\n            //send stakers's lock share of veAsset to VE3D locker reward contract\n            if (_stakerLockIncentive > 0) {\n                IERC20(veAsset).safeTransfer(stakerLockRewards, _stakerLockIncentive);\n                IRewards(stakerLockRewards).queueNewRewards(veAsset, _stakerLockIncentive);\n            }\n        }\n    }\n\n    function earmarkRewards(uint256 _pid) external returns (bool) {\n        require(!isShutdown, \"shutdown\");\n        _earmarkRewards(_pid);\n        return true;\n    }\n\n    //claim fees from fee distro contract, put in lockers' reward contract\n    function earmarkFees() external returns (bool) {\n        //claim fee rewards\n        IStaker(staker).claimFees(feeDistro, feeToken);\n        //send fee rewards to reward contract\n        uint256 _balance = IERC20(feeToken).balanceOf(address(this));\n\n        uint256 _lockFeesIncentive = _balance.mul(lockFeesIncentive).div(FEE_DENOMINATOR);\n        uint256 _stakerLockFeesIncentive = _balance.mul(stakerLockFeesIncentive).div(\n            FEE_DENOMINATOR\n        );\n        if (_lockFeesIncentive > 0) {\n            IERC20(feeToken).safeTransfer(lockFees, _lockFeesIncentive);\n            IRewards(lockFees).queueNewRewards(_lockFeesIncentive);\n        }\n        if (_stakerLockFeesIncentive > 0) {\n            IERC20(feeToken).safeTransfer(stakerLockRewards, _stakerLockFeesIncentive);\n            IRewards(stakerLockRewards).queueNewRewards(feeToken, _stakerLockFeesIncentive);\n        }\n        return true;\n    }\n\n    //callback from reward contract when veAsset is received.\n    function rewardClaimed(\n        uint256 _pid,\n        address _address,\n        uint256 _amount\n    ) external returns (bool) {\n        address rewardContract = poolInfo[_pid].veAssetRewards;\n        require(msg.sender == rewardContract || msg.sender == lockRewards, \"!auth\");\n        ITokenMinter veTokenMinter = ITokenMinter(minter);\n        //calc the amount of veAssetEarned\n        uint256 _veAssetEarned = _amount.mul(veTokenMinter.veAssetWeights(address(this))).div(\n            veTokenMinter.totalWeight()\n        );\n        //mint reward tokens\n        ITokenMinter(minter).mint(_address, _veAssetEarned);\n\n        return true;\n    }\n}"
}