V2 strategy

pragma solidity ^0.7.3;
pragma experimental ABIEncoderV2;

interface IERC20 {
    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function transfer(address recipient, uint256 amount)
        external
        returns (bool);

    function allowance(address owner, address spender)
        external
        view
        returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
}

library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;
        return c;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;

        return c;
    }
}

library Address {
    function isContract(address account) internal view returns (bool) {
        bytes32 codehash;
        bytes32 accountHash =
            0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            codehash := extcodehash(account)
        }
        return (codehash != accountHash && codehash != 0x0);
    }

    function toPayable(address account)
        internal
        pure
        returns (address payable)
    {
        return address(uint160(account));
    }
}

library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        callOptionalReturn(
            token,
            abi.encodeWithSelector(token.transfer.selector, to, value)
        );
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        callOptionalReturn(
            token,
            abi.encodeWithSelector(token.transferFrom.selector, from, to, value)
        );
    }

    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        callOptionalReturn(
            token,
            abi.encodeWithSelector(token.approve.selector, spender, value)
        );
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance =
            token.allowance(address(this), spender).add(value);
        callOptionalReturn(
            token,
            abi.encodeWithSelector(
                token.approve.selector,
                spender,
                newAllowance
            )
        );
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance =
            token.allowance(address(this), spender).sub(
                value,
                "SafeERC20: decreased allowance below zero"
            );
        callOptionalReturn(
            token,
            abi.encodeWithSelector(
                token.approve.selector,
                spender,
                newAllowance
            )
        );
    }

    function callOptionalReturn(IERC20 token, bytes memory data) private {
        require(address(token).isContract(), "SafeERC20: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = address(token).call(data);
        require(success, "SafeERC20: low-level call failed");

        if (returndata.length > 0) {
            // Return data is optional
            // solhint-disable-next-line max-line-length
            require(
                abi.decode(returndata, (bool)),
                "SafeERC20: ERC20 operation did not succeed"
            );
        }
    }
}

//
interface IController {
    function withdraw(address, uint256) external;

    function balanceOf(address) external view returns (uint256);

    function earn(address, uint256) external;

    function want(address) external view returns (address);

    function rewards() external view returns (address);

    function vaults(address) external view returns (address);

    function strategies(address) external view returns (address);
}

//
interface Uni {
    function swapExactTokensForTokens(
        uint256,
        uint256,
        address[] calldata,
        address,
        uint256
    ) external;
}

interface CToken {
    function totalSupply() external view returns (uint256);

    function totalBorrows() external returns (uint256);

    function borrowIndex() external returns (uint256);

    function repayBorrow(uint256 repayAmount) external returns (uint256);

    function redeem(uint redeemTokens) external returns (uint);

    function redeemUnderlying(uint256 redeemAmount) external returns (uint256);

    function borrow(uint256 borrowAmount) external returns (uint256);

    function mint(uint256 mintAmount) external returns (uint256);

    function underlying() external view returns (address);

    function transfer(address dst, uint256 amount) external returns (bool);

    function transferFrom(
        address src,
        address dst,
        uint256 amount
    ) external returns (bool);

    function approve(address spender, uint256 amount) external returns (bool);

    function allowance(address owner, address spender)
        external
        view
        returns (uint256);

    function balanceOf(address owner) external view returns (uint256);

    function balanceOfUnderlying(address owner) external returns (uint256);

    function getAccountSnapshot(address account)
        external
        view
        returns (
            uint256,
            uint256,
            uint256,
            uint256
        );

    function borrowRatePerBlock() external view returns (uint256);

    function supplyRatePerBlock() external view returns (uint256);

    function totalBorrowsCurrent() external returns (uint256);

    function borrowBalanceCurrent(address account) external returns (uint256);

    function borrowBalanceStored(address account)
        external
        view
        returns (uint256);

    function exchangeRateCurrent() external returns (uint256);

    function exchangeRateStored() external view returns (uint256);

    function getCash() external view returns (uint256);

    function accrueInterest() external returns (uint256);

    function seize(
        address liquidator,
        address borrower,
        uint256 seizeTokens
    ) external returns (uint256);
}

interface IUnitroller {
    function compAccrued(address) external view returns (uint256);

    function compSupplierIndex(address, address)
        external
        view
        returns (uint256);

    function compBorrowerIndex(address, address)
        external
        view
        returns (uint256);

    function compSpeeds(address) external view returns (uint256);

    function compBorrowState(address) external view returns (uint224, uint32);

    function compSupplyState(address) external view returns (uint224, uint32);

    /*** Assets You Are In ***/

    function enterMarkets(address[] calldata cTokens)
        external
        returns (uint256[] memory);

    function exitMarket(address cToken) external returns (uint256);

    /*** Policy Hooks ***/

    function mintAllowed(
        address cToken,
        address minter,
        uint256 mintAmount
    ) external returns (uint256);

    function mintVerify(
        address cToken,
        address minter,
        uint256 mintAmount,
        uint256 mintTokens
    ) external;

    function redeemAllowed(
        address cToken,
        address redeemer,
        uint256 redeemTokens
    ) external returns (uint256);

    function redeemVerify(
        address cToken,
        address redeemer,
        uint256 redeemAmount,
        uint256 redeemTokens
    ) external;

    function borrowAllowed(
        address cToken,
        address borrower,
        uint256 borrowAmount
    ) external returns (uint256);

    function borrowVerify(
        address cToken,
        address borrower,
        uint256 borrowAmount
    ) external;

    function repayBorrowAllowed(
        address cToken,
        address payer,
        address borrower,
        uint256 repayAmount
    ) external returns (uint256);

    function repayBorrowVerify(
        address cToken,
        address payer,
        address borrower,
        uint256 repayAmount,
        uint256 borrowerIndex
    ) external;

    function liquidateBorrowAllowed(
        address cTokenBorrowed,
        address cTokenCollateral,
        address liquidator,
        address borrower,
        uint256 repayAmount
    ) external returns (uint256);

    function liquidateBorrowVerify(
        address cTokenBorrowed,
        address cTokenCollateral,
        address liquidator,
        address borrower,
        uint256 repayAmount,
        uint256 seizeTokens
    ) external;

    function seizeAllowed(
        address cTokenCollateral,
        address cTokenBorrowed,
        address liquidator,
        address borrower,
        uint256 seizeTokens
    ) external returns (uint256);

    function seizeVerify(
        address cTokenCollateral,
        address cTokenBorrowed,
        address liquidator,
        address borrower,
        uint256 seizeTokens
    ) external;

    function transferAllowed(
        address cToken,
        address src,
        address dst,
        uint256 transferTokens
    ) external returns (uint256);

    function transferVerify(
        address cToken,
        address src,
        address dst,
        uint256 transferTokens
    ) external;

    /*** Liquidity/Liquidation Calculations ***/

    function liquidateCalculateSeizeTokens(
        address cTokenBorrowed,
        address cTokenCollateral,
        uint256 repayAmount
    ) external view returns (uint256, uint256);

    // Claim all the COMP accrued by holder in all markets
    function claimVenus(address holder) external;

    // Claim all the COMP accrued by holder in specific markets
    function claimVenus(address holder, address[] calldata cTokens) external;

    // Claim all the COMP accrued by specific holders in specific markets for their supplies and/or borrows
    function claimVenus(
        address[] calldata holders,
        address[] calldata cTokens,
        bool borrowers,
        bool suppliers
    ) external;

    function markets(address cTokenAddress)
        external
        view
        returns (bool, uint256);
}

interface IWETH {
    function deposit() external payable;

    function transfer(address to, uint256 value) external returns (bool);

    function withdraw(uint256 amt) external;
}

contract StrategyBUSD {
    using SafeERC20 for IERC20;
    using Address for address;
    using SafeMath for uint256;

   
    address public constant newb = 0x545f90dC35CA1e6129f1fEd354b3e2DF12034261;
    address public constant busd = 0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56;
    address public constant usdt = 0x55d398326f99059fF775485246999027B3197955;
    address public constant uniRouter =
        0x05fF2B0DB69458A0750badebc4f9e13aDd608C7F;

    uint256 public strategistReward = 10;
    uint256 public reinvest = 90;
    uint256 public withdrawalFee = 500;
    uint256 public constant FEE_DENOMINATOR = 10000;

    address public constant comptrl =
        0xfD36E2c2a6789Db23113685031d7F16329158384;
    address public comp = 0xcF6BB5389c92Bdda8a3747Ddb454cB7a64626C63;

    address public ctoken;
    address public want;

    address public governance;
    address public controller;
    address public strategist;

    mapping(address => bool) public farmers;

    constructor(
        address _controller,
        address _ctoken,
        address _want
    ) {
        governance = msg.sender;
        strategist = msg.sender;
        controller = _controller;
        ctoken = _ctoken;
        want = _want;
        require(CToken(ctoken).underlying() == want, "mismatch");
    }

    function addFarmer(address f) public {
        require(
            msg.sender == governance || msg.sender == strategist,
            "!authorized"
        );
        farmers[f] = true;
    }

    function removeFarmer(address f) public {
        require(
            msg.sender == governance || msg.sender == strategist,
            "!authorized"
        );
        farmers[f] = false;
    }

    function setGovernance(address _governance) external {
        require(msg.sender == governance, "!governance");
        governance = _governance;
    }
    
    function setStrategist(address _strategist) external {
        require(
            msg.sender == governance || msg.sender == strategist,
            "!authorized"
        );
        strategist = _strategist;
    }

    function setWithdrawalFee(uint256 _withdrawalFee) external {
        require(msg.sender == governance, "!governance");
        withdrawalFee = _withdrawalFee;
    }

    function setStrategistReward(uint256 _strategistReward) external {
        require(msg.sender == governance, "!governance");
        strategistReward = _strategistReward;
    }
    
    function setReinvest(uint256 _reinvest) external {
        require(msg.sender == governance, "!governance");
        reinvest = _reinvest;
    }

    function getSuppliedView() public view returns (uint256) {
        (, uint256 cTokenBal, , uint256 exchangeRate) =
            CToken(ctoken).getAccountSnapshot(address(this));

        return cTokenBal.mul(exchangeRate).div(1e18);
    }

    function getBorrowedView() public view returns (uint256) {
        return CToken(ctoken).borrowBalanceStored(address(this));
    }

    function balanceOfPool() public view returns (uint256) {
        uint256 supplied = getSuppliedView();
        uint256 borrowed = getBorrowedView();
        uint b = supplied.sub(borrowed);
        return b;
    }

    function balanceOfWant() public view returns (uint256) {
        return IERC20(want).balanceOf(address(this));
    }

    function balanceOf() public view returns (uint256) {
        return balanceOfWant().add(balanceOfPool());
    }

   

    function getSupplied() public returns (uint256) {
        return CToken(ctoken).balanceOfUnderlying(address(this));
    }

    function getBorrowed() public returns (uint256) {
        return CToken(ctoken).borrowBalanceCurrent(address(this));
    }

    

    modifier onlyBenevolent {
        require(
            farmers[msg.sender] ||
                msg.sender == governance ||
                msg.sender == strategist
        );
        _;
    }
    
    
    function harvest() public onlyBenevolent {
        address[] memory markets = new address[](1);
        markets[0] = ctoken;
        IUnitroller(comptrl).claimVenus(address(this), markets);
        uint256 _comp = IERC20(comp).balanceOf(address(this));

        if (_comp > 0) {
            IERC20(comp).safeApprove(uniRouter, 0);
            IERC20(comp).safeApprove(uniRouter, uint256(-1));
            
            uint256 _2want = IERC20(comp).balanceOf(address(this)).mul(reinvest).div(100);
            uint256 _2token = IERC20(comp).balanceOf(address(this)).mul(strategistReward).div(100);
            address[] memory path = new address[](2); 
            
            // 2token  
                path[0] = comp;
                path[1] = busd;
                Uni(uniRouter).swapExactTokensForTokens(
                    _2token,
                    uint256(0),
                    path,
                    address(this),
                    block.timestamp.add(1800)
                );
                IERC20(busd).safeApprove(uniRouter, 0);
                IERC20(busd).safeApprove(uniRouter, uint256(-1));
                path[0] = busd;
                path[1] = newb;
                Uni(uniRouter).swapExactTokensForTokens(
                    IERC20(busd).balanceOf(address(this)),
                    uint256(0),
                    path,
                    address(this),
                    block.timestamp.add(1800)
                );
            
            //2want
            path[0] = comp;
            path[1] = busd;
            Uni(uniRouter).swapExactTokensForTokens(
                    _2want,
                    uint256(0),
                    path,
                    address(this),
                    block.timestamp.add(1800)
            );
            if (want != busd) {
                IERC20(busd).safeApprove(uniRouter, 0);
                IERC20(busd).safeApprove(uniRouter, uint256(-1));
                path[0] = busd;
                path[1] = want;
                Uni(uniRouter).swapExactTokensForTokens(
                    IERC20(busd).balanceOf(address(this)),
                    uint256(0),
                    path,
                    address(this),
                    block.timestamp.add(1800)
                );
            }
                
        }
        uint256 gain = IERC20(newb).balanceOf(address(this));
        if (gain > 0) {
            IERC20(newb).safeTransfer(strategist, gain); 
        }
        
        _deposit();
    }

    function deposit() public {
        
        _deposit();
    }

    function _deposit() internal returns (uint) {
        uint256 _want = IERC20(want).balanceOf(address(this));
        if (_want > 0) {
            IERC20(want).safeApprove(ctoken, 0);
            IERC20(want).safeApprove(ctoken, _want);
            require(CToken(ctoken).mint(_want) == 0, "!deposit");
        }
        return _want;
    }

    function _withdrawSome(uint256 _amount) internal returns (uint256) {
        // -- CoinFabrik: save initial balance --
        uint256 _balance = balanceOfWant();
        uint256 _redeem = _amount;

        // Make sure market can cover liquidity
        require(CToken(ctoken).getCash() >= _redeem, "!cash-liquidity");

        // How much borrowed amount do we need to free?
        uint256 borrowed = getBorrowed();
        uint256 supplied = getSupplied();
        if (_redeem > supplied.sub(borrowed)) {
            _redeem = supplied.sub(borrowed);
        }

        // Redeems underlying
        if (_redeem > 0) {
            require(CToken(ctoken).redeemUnderlying(_redeem) == 0, "!redeem");
        }

        // -- CoinFabrik: calculate tokens redeemed --
        uint256 _reedemed = balanceOfWant();
        _reedemed = _reedemed.sub(_balance);

        return _reedemed;
    }

    function withdrawAll() external returns (uint256 balance) {
        require(msg.sender == controller, "!controller");
        _withdrawAll();

        balance = IERC20(want).balanceOf(address(this));

        address _vault = IController(controller).vaults(address(want));
        require(_vault != address(0), "!vault"); // additional protection so we don't burn the funds
        IERC20(want).safeTransfer(_vault, balance);
    }

    function _withdrawAll() internal {
        uint256 borrowed = getBorrowed();
        uint256 supplied = getSupplied();
        _withdrawSome(supplied.sub(borrowed));
    }

    function withdraw(uint256 _amount) external {
        require(msg.sender == controller, "!controller");
        uint256 _balance = IERC20(want).balanceOf(address(this));
        if (_balance < _amount) {
            _amount = _withdrawSome(_amount.sub(_balance));
            _amount = _amount.add(_balance);
        }

        uint256 _fee = _amount.mul(withdrawalFee).div(FEE_DENOMINATOR);

        if (_fee > 0) {
            IERC20(want).safeTransfer(IController(controller).rewards(), _fee);
        }
        address _vault = IController(controller).vaults(address(want));
        require(_vault != address(0), "!vault"); // additional protection so we don't burn the funds
        IERC20(want).safeTransfer(_vault, _amount.sub(_fee));
    }

    function withdraw(IERC20 _asset) external returns (uint256 balance) {
        require(msg.sender == controller, "!controller");
        require(want != address(_asset), "want");
        require(ctoken != address(_asset), "want");
        require(comp != address(_asset), "want");
        balance = _asset.balanceOf(address(this));
        _asset.safeTransfer(controller, balance);
    }


    // emergency functions
    function e_exit() public {
        require(msg.sender == governance, "!governance");
        //deleverageToMin();
        uint amt = CToken(ctoken).balanceOf(address(this));
        if (amt > 0) {
            require(CToken(ctoken).redeem(amt) == 0, "!e_redeem");
        }
        
        uint balance = IERC20(want).balanceOf(address(this));
        if (balance > 0) {
            address _vault = IController(controller).vaults(address(want));
            require(_vault != address(0), "!vault"); // additional protection so we don't burn the funds
            IERC20(want).safeTransfer(_vault, balance);
        }
    }
    function e_redeem(uint amount) public {
        require(msg.sender == governance, "!governance");
        require(CToken(ctoken).redeemUnderlying(amount) == 0, "!e_redeem");
    }

    function e_redeemAll() public {
        require(msg.sender == governance, "!governance");
        uint amt = CToken(ctoken).balanceOfUnderlying(address(this));
        require(CToken(ctoken).redeemUnderlying(amt) == 0, "!e_redeem");
    }

    function e_redeemCToken(uint amount) public {
        require(msg.sender == governance, "!governance");
        require(CToken(ctoken).redeem(amount) == 0, "!e_redeem");
    }

    function e_redeemAllCToken() public {
        require(msg.sender == governance, "!governance");
        uint amt = CToken(ctoken).balanceOf(address(this));
        require(CToken(ctoken).redeem(amt) == 0, "!e_redeem");
    }

    function e_repayAll() public {
        require(msg.sender == governance, "!governance");
        IERC20(want).safeApprove(ctoken, 0);
        IERC20(want).safeApprove(ctoken, uint256(-1));
        uint borrowed = CToken(ctoken).borrowBalanceCurrent(address(this));
        uint bl = IERC20(want).balanceOf(address(this));
        if (bl > borrowed) {
            require(CToken(ctoken).repayBorrow(borrowed) == 0, "!repay");
        } else {
            require(CToken(ctoken).repayBorrow(bl) == 0, "!repay");
        }
    }

    function e_repay(uint amount) public {
        require(msg.sender == governance, "!governance");
        IERC20(want).safeApprove(ctoken, 0);
        IERC20(want).safeApprove(ctoken, uint256(-1));
        uint borrowed = CToken(ctoken).borrowBalanceCurrent(address(this));
        uint bl = IERC20(want).balanceOf(address(this));
        require(amount <= bl);
        if (amount > borrowed) {
            require(CToken(ctoken).repayBorrow(borrowed) == 0, "!repay");
        } else {
            require(CToken(ctoken).repayBorrow(amount) == 0, "!repay");
        }
    }

    function e_collect() public {
        require(msg.sender == governance, "!governance");
        uint balance = IERC20(want).balanceOf(address(this));

        address _vault = IController(controller).vaults(address(want));
        require(_vault != address(0), "!vault"); // additional protection so we don't burn the funds
        IERC20(want).safeTransfer(_vault, balance);
    }

    receive() external payable {}
}