Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionCallWithValue(addres ...
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(address t ...
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(address ...
•    - function _verifyCallResult(bool succe ...
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• library SafeMath
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b, st ...
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeApprove(IERC20 token, ad ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function _callOptionalReturn(IERC20 t ...
• library Math
•    - function min(uint256 a, uint256 b)
• interface IBasicRewards
•    - function getReward(address _account, ...
•    - function stakeFor(address, uint256)
• interface ICvxRewards
•    - function getReward(address _account, ...
• interface IChefRewards
•    - function claim(uint256 _pid, address ...
• interface ICvxCrvDeposit
•    - function deposit(uint256, bool)
•  contract ClaimZap *
•    - function setChefRewards(address _rewa ...
•    - function setApprovals()
•    - function claimRewards(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-05-31
*/

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.2 <0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// File: @openzeppelin\contracts\token\ERC20\IERC20.sol
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);
}


// File: node_modules\@openzeppelin\contracts\math\SafeMath.sol
pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b > a) return (false, 0);
        return (true, a - b);
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) return (true, 0);
        uint256 c = a * b;
        if (c / a != b) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a / b);
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a % b);
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    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;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: modulo by zero");
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        return a - b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a % b;
    }
}


// File: @openzeppelin\contracts\token\ERC20\SafeERC20.sol
pragma solidity >=0.6.0 <0.8.0;




/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
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));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    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));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "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");
        }
    }
}

// File: contracts\ClaimZap.sol
pragma solidity 0.6.12;


library Math {
    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }
}

interface IBasicRewards{
    function getReward(address _account, bool _claimExtras) external;
    function stakeFor(address, uint256) external;
}

interface ICvxRewards{
    function getReward(address _account, bool _claimExtras, bool _stake) external;
}

interface IChefRewards{
    function claim(uint256 _pid, address _account) external;
}

interface ICvxCrvDeposit{
    function deposit(uint256, bool) external;
}

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

    address public constant crv = address(0xD533a949740bb3306d119CC777fa900bA034cd52);
    address public constant cvx = address(0x4e3FBD56CD56c3e72c1403e103b45Db9da5B9D2B);
    address public constant cvxCrv = address(0x62B9c7356A2Dc64a1969e19C23e4f579F9810Aa7);
    address public constant crvDeposit = address(0x8014595F2AB54cD7c604B00E9fb932176fDc86Ae);
    address public constant cvxCrvRewards = address(0x3Fe65692bfCD0e6CF84cB1E7d24108E434A7587e);
    address public constant cvxRewards = address(0xCF50b810E57Ac33B91dCF525C6ddd9881B139332);

    address public immutable owner;
    address public chefRewards;

    constructor() public {
        owner = msg.sender;
        chefRewards = address(0x5F465e9fcfFc217c5849906216581a657cd60605);
    }

    function setChefRewards(address _rewards) external {
        require(msg.sender == owner, "!auth");
        chefRewards = _rewards;
    }

    function setApprovals() external {
        require(msg.sender == owner, "!auth");
        IERC20(crv).safeApprove(crvDeposit, 0);
        IERC20(crv).safeApprove(crvDeposit, uint256(-1));
        IERC20(cvx).safeApprove(cvxRewards, 0);
        IERC20(cvx).safeApprove(cvxRewards, uint256(-1));
        IERC20(cvxCrv).safeApprove(cvxCrvRewards, 0);
        IERC20(cvxCrv).safeApprove(cvxCrvRewards, uint256(-1));
    }

    function claimRewards(
        address[] calldata rewardContracts,
        uint256[] calldata chefIds,
        bool claimCvx,
        bool claimCvxStake,
        bool claimcvxCrv,
        uint256 depositCrvMaxAmount,
        uint256 depositCvxMaxAmount
        ) external{

        //claim from main curve LP pools
        for(uint256 i = 0; i < rewardContracts.length; i++){
            if(rewardContracts[i] == address(0)) break;
            IBasicRewards(rewardContracts[i]).getReward(msg.sender,true);
        }

        //claim from master chef
        for(uint256 i = 0; i < chefIds.length; i++){
            IChefRewards(chefRewards).claim(chefIds[i],msg.sender);
        }

        //claim (and stake) from cvx rewards
        if(claimCvxStake){
            ICvxRewards(cvxRewards).getReward(msg.sender,true,true);
        }else if(claimCvx){
            ICvxRewards(cvxRewards).getReward(msg.sender,true,false);
        }

        //claim from cvxCrv rewards
        if(claimcvxCrv){
            IBasicRewards(cvxCrvRewards).getReward(msg.sender,true);
        }

        //lock upto given amount of crv and stake
        if(depositCrvMaxAmount > 0){
            uint256 crvBalance = IERC20(crv).balanceOf(msg.sender);
            crvBalance = Math.min(crvBalance, depositCrvMaxAmount);
            if(crvBalance > 0){
                //pull crv
                IERC20(crv).safeTransferFrom(msg.sender, address(this), crvBalance);
                //deposit
                ICvxCrvDeposit(crvDeposit).deposit(crvBalance,true);
                //get cvxamount
                uint256 cvxCrvBalance = IERC20(cvxCrv).balanceOf(address(this));
                //stake for msg.sender
                IBasicRewards(cvxCrvRewards).stakeFor(msg.sender, cvxCrvBalance);
            }
        }

        //stake upto given amount of cvx
        if(depositCvxMaxAmount > 0){
            uint256 cvxBalance = IERC20(cvx).balanceOf(msg.sender);
            cvxBalance = Math.min(cvxBalance, depositCvxMaxAmount);
            if(cvxBalance > 0){
                //pull cvx
                IERC20(cvx).safeTransferFrom(msg.sender, address(this), cvxBalance);
                //stake for msg.sender
                IBasicRewards(cvxRewards).stakeFor(msg.sender, cvxBalance);
            }
        }
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"chefRewards","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"rewardContracts","type":"address[]"},{"internalType":"uint256[]","name":"chefIds","type":"uint256[]"},{"internalType":"bool","name":"claimCvx","type":"bool"},{"internalType":"bool","name":"claimCvxStake","type":"bool"},{"internalType":"bool","name":"claimcvxCrv","type":"bool"},{"internalType":"uint256","name":"depositCrvMaxAmount","type":"uint256"},{"internalType":"uint256","name":"depositCvxMaxAmount","type":"uint256"}],"name":"claimRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"crv","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"crvDeposit","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cvx","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cvxCrv","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cvxCrvRewards","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cvxRewards","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"setApprovals","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_rewards","type":"address"}],"name":"setChefRewards","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

22723:3835:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22847:81;;;:::i;:::-;;;;-1:-1:-1;;;;;22847:81:0;;;;;;;;;;;;;;24199:2356;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;24199:2356:0;-1:-1:-1;24199:2356:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;23023:84;;;:::i;23766:425::-;;;:::i;23404:30::-;;;:::i;22935:81::-;;;:::i;23209:91::-;;;:::i;23307:88::-;;;:::i;23114:::-;;;:::i;23441:26::-;;;:::i;23618:140::-;;;;;;;;;;;;;;;;-1:-1:-1;23618:140:0;-1:-1:-1;;;;;23618:140:0;;:::i;22847:81::-;22885:42;22847:81;:::o;24199:2356::-;24537:9;24533:195;24552:26;;;24533:195;;;24632:1;24602:15;;24618:1;24602:18;;;;;;;;;;;;;-1:-1:-1;;;;;24602:18:0;-1:-1:-1;;;;;24602:32:0;;24599:42;;;24636:5;;24599:42;24670:15;;24686:1;24670:18;;;;;;;;;;;;;-1:-1:-1;;;;;24670:18:0;-1:-1:-1;;;;;24656:43:0;;24700:10;24711:4;24656:60;;;;;;;;;;;;;-1:-1:-1;;;;;24656:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;24580:3:0;;;;;-1:-1:-1;24533:195:0;;-1:-1:-1;24533:195:0;;;24778:9;24774:124;24793:18;;;24774:124;;;24845:11;;-1:-1:-1;;;;;24845:11:0;24832:31;24864:7;;24872:1;24864:10;;;;;;;;;;;;;24875;24832:54;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;24832:54:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;24813:3:0;;;;;-1:-1:-1;24774:124:0;;-1:-1:-1;24774:124:0;;;24959:13;24956:199;;;24988:55;;;-1:-1:-1;;;24988:55:0;;25022:10;24988:55;;;;25033:4;24988:55;;;;;;;;;;;;23352:42;;24988:33;;:55;;;;;-1:-1:-1;;24988:55:0;;;;;;;-1:-1:-1;23352:42:0;24988:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24956:199;;;25063:8;25060:95;;;25087:56;;;-1:-1:-1;;;25087:56:0;;25121:10;25087:56;;;;25132:4;25087:56;;;;25137:5;25087:56;;;;;;;;23352:42;;25087:33;;:56;;;;;;;;;;;25137:5;23352:42;25087:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25060:95;25207:11;25204:97;;;25234:55;;;-1:-1:-1;;;25234:55:0;;25273:10;25234:55;;;;25284:4;25234:55;;;;;;23257:42;;25234:38;;:55;;;;;-1:-1:-1;;25234:55:0;;;;;;;-1:-1:-1;23257:42:0;25234:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25204:97;25367:23;;25364:674;;25427:33;;;-1:-1:-1;;;25427:33:0;;25449:10;25427:33;;;;;;25406:18;;22885:42;;25427:21;;:33;;;;;;;;;;;;;;;22885:42;25427:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;25427:33:0;;-1:-1:-1;25488:41:0;25427:33;25509:19;25488:8;:41::i;:::-;25475:54;-1:-1:-1;25547:14:0;;25544:483;;25609:67;22885:42;25638:10;25658:4;25665:10;25609:28;:67::i;:::-;25722:51;;;-1:-1:-1;;;25722:51:0;;;;;;;;25768:4;25722:51;;;;;;23159:42;;25722:34;;:51;;;;;-1:-1:-1;;25722:51:0;;;;;;;-1:-1:-1;23159:42:0;25722:51;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;25849:39:0;;;-1:-1:-1;;;25849:39:0;;25882:4;25849:39;;;;;;25825:21;;-1:-1:-1;23064:42:0;;-1:-1:-1;25849:24:0;;:39;;;;;;;;;;;;;;;23064:42;25849:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;25849:39:0;25947:64;;;-1:-1:-1;;;25947:64:0;;25985:10;25947:64;;;;;;;;;;;;25849:39;;-1:-1:-1;23257:42:0;;25947:37;;:64;;;;;-1:-1:-1;;25947:64:0;;;;;;;;-1:-1:-1;23257:42:0;25947:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25544:483;;25364:674;;26095:23;;26092:456;;26155:33;;;-1:-1:-1;;;26155:33:0;;26177:10;26155:33;;;;;;26134:18;;22973:42;;26155:21;;:33;;;;;;;;;;;;;;;22973:42;26155:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;26155:33:0;;-1:-1:-1;26216:41:0;26155:33;26237:19;26216:8;:41::i;:::-;26203:54;-1:-1:-1;26275:14:0;;26272:265;;26337:67;22973:42;26366:10;26386:4;26393:10;26337:28;:67::i;:::-;26463:58;;;-1:-1:-1;;;26463:58:0;;26498:10;26463:58;;;;;;;;;;;;23352:42;;26463:34;;:58;;;;;-1:-1:-1;;26463:58:0;;;;;;;-1:-1:-1;23352:42:0;26463:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26272:265;26092:456;;24199:2356;;;;;;;;;:::o;23023:84::-;23064:42;23023:84;:::o;23766:425::-;23818:10;-1:-1:-1;;;;;23832:5:0;23818:19;;23810:37;;;;;-1:-1:-1;;;23810:37:0;;;;;;;;;;;;-1:-1:-1;;;23810:37:0;;;;;;;;;;;;;;;23858:38;22885:42;23159;23894:1;23858:23;:38::i;:::-;23907:48;22885:42;23159;-1:-1:-1;;23907:23:0;:48::i;:::-;23966:38;22973:42;23352;24002:1;23966:23;:38::i;:::-;24015:48;22973:42;23352;-1:-1:-1;;24015:23:0;:48::i;:::-;24074:44;23064:42;23257;24116:1;24074:26;:44::i;:::-;24129:54;23064:42;23257;-1:-1:-1;;24129:26:0;:54::i;:::-;23766:425::o;23404:30::-;;;:::o;22935:81::-;22973:42;22935:81;:::o;23209:91::-;23257:42;23209:91;:::o;23307:88::-;23352:42;23307:88;:::o;23114:::-;23159:42;23114:88;:::o;23441:26::-;;;-1:-1:-1;;;;;23441:26:0;;:::o;23618:140::-;23688:10;-1:-1:-1;;;;;23702:5:0;23688:19;;23680:37;;;;;-1:-1:-1;;;23680:37:0;;;;;;;;;;;;-1:-1:-1;;;23680:37:0;;;;;;;;;;;;;;;23728:11;:22;;-1:-1:-1;;;;;;23728:22:0;-1:-1:-1;;;;;23728:22:0;;;;;;;;;;23618:140::o;22173:106::-;22231:7;22262:1;22258;:5;:13;;22270:1;22258:13;;;22266:1;22258:13;22251:20;22173:106;-1:-1:-1;;;22173:106:0:o;19135:205::-;19263:68;;;-1:-1:-1;;;;;19263:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;19263:68:0;-1:-1:-1;;;19263:68:0;;;19236:96;;19256:5;;19236:19;:96::i;:::-;19135:205;;;;:::o;19609:622::-;19979:10;;;19978:62;;-1:-1:-1;19995:39:0;;;-1:-1:-1;;;19995:39:0;;20019:4;19995:39;;;;-1:-1:-1;;;;;19995:39:0;;;;;;;;;:15;;;;;;:39;;;;;;;;;;;;;;;:15;:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;19995:39:0;:44;19978:62;19970:152;;;;-1:-1:-1;;;19970:152:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20160:62;;;-1:-1:-1;;;;;20160:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;20160:62:0;-1:-1:-1;;;20160:62:0;;;20133:90;;20153:5;;20133:19;:90::i;:::-;19609:622;;;:::o;21255:761::-;21679:23;21705:69;21733:4;21705:69;;;;;;;;;;;;;;;;;21713:5;-1:-1:-1;;;;;21705:27:0;;;:69;;;;;:::i;:::-;21789:17;;21679:95;;-1:-1:-1;21789:21:0;21785:224;;21931:10;21920:30;;;;;;;;;;;;;;;-1:-1:-1;21920:30:0;21912:85;;;;-1:-1:-1;;;21912:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3669:195;3772:12;3804:52;3826:6;3834:4;3840:1;3843:12;3804:21;:52::i;:::-;3797:59;3669:195;-1:-1:-1;;;;3669:195:0:o;4721:530::-;4848:12;4906:5;4881:21;:30;;4873:81;;;;-1:-1:-1;;;4873:81:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4973:18;4984:6;4973:10;:18::i;:::-;4965:60;;;;;-1:-1:-1;;;4965:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;5099:12;5113:23;5140:6;-1:-1:-1;;;;;5140:11:0;5160:5;5168:4;5140:33;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;5140:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5098:75;;;;5191:52;5209:7;5218:10;5230:12;5191:17;:52::i;:::-;5184:59;4721:530;-1:-1:-1;;;;;;;4721:530:0:o;751:422::-;1118:20;1157:8;;;751:422::o;7261:742::-;7376:12;7405:7;7401:595;;;-1:-1:-1;7436:10:0;7429:17;;7401:595;7550:17;;:21;7546:439;;7813:10;7807:17;7874:15;7861:10;7857:2;7853:19;7846:44;7761:148;7956:12;7949:20;;-1:-1:-1;;;7949:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

ipfs://8fbc598eda7c67ae36f6ccc43c33df307301be9ae71e3ddb1d413e6a4dbe870b