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 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)
• interface ISwapExchange
•    - function swapExactTokensForTokens(
•  contract ClaimZap *
•    - function setApprovals()
•    - function claimRewards(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-07-21
*/

// SPDX-License-Identifier: MIT

// File: @openzeppelin\contracts\utils\Address.sol

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 getReward(address _account) 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;
}

interface ISwapExchange {
    function swapExactTokensForTokens(
        uint256,
        uint256,
        address[] calldata,
        address,
        uint256
    ) 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 constant exchange = address(0xd9e1cE17f2641f24aE83637ab66a2cca9C378B9F);

    address public immutable owner;

    constructor() public {
        owner = msg.sender;
    }

    function setApprovals() external {
        require(msg.sender == owner, "!auth");
        IERC20(crv).safeApprove(crvDeposit, 0);
        IERC20(crv).safeApprove(crvDeposit, uint256(-1));
        IERC20(crv).safeApprove(exchange, 0);
        IERC20(crv).safeApprove(exchange, 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,
        address[] calldata extraRewardContracts,
        bool claimCvx,
        bool claimCvxStake,
        bool claimcvxCrv,
        bool lockCrvDeposit,
        uint256 depositCrvMaxAmount,
        uint256 minAmountOut,
        uint256 depositCvxMaxAmount
        ) external{

        uint256 crvBalance = IERC20(crv).balanceOf(msg.sender);
        uint256 cvxBalance = IERC20(cvx).balanceOf(msg.sender);

        //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);
        }

        for(uint256 i = 0; i < extraRewardContracts.length; i++){
            if(extraRewardContracts[i] == address(0)) break;
            IBasicRewards(extraRewardContracts[i]).getReward(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){
            crvBalance = IERC20(crv).balanceOf(msg.sender).sub(crvBalance);
            crvBalance = Math.min(crvBalance, depositCrvMaxAmount);
            if(crvBalance > 0){
                //pull crv
                IERC20(crv).safeTransferFrom(msg.sender, address(this), crvBalance);
                if(minAmountOut > 0){
                    //swap
                    address[] memory path = new address[](2);
                    path[0] = crv;
                    path[1] = cvxCrv;
                    ISwapExchange(exchange).swapExactTokensForTokens(crvBalance,minAmountOut,path,address(this),now.add(1800));
                }else{
                    //deposit
                    ICvxCrvDeposit(crvDeposit).deposit(crvBalance,lockCrvDeposit);
                }
                //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){
            cvxBalance = IERC20(cvx).balanceOf(msg.sender).sub(cvxBalance);
            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":[{"internalType":"address[]","name":"rewardContracts","type":"address[]"},{"internalType":"address[]","name":"extraRewardContracts","type":"address[]"},{"internalType":"bool","name":"claimCvx","type":"bool"},{"internalType":"bool","name":"claimCvxStake","type":"bool"},{"internalType":"bool","name":"claimcvxCrv","type":"bool"},{"internalType":"bool","name":"lockCrvDeposit","type":"bool"},{"internalType":"uint256","name":"depositCrvMaxAmount","type":"uint256"},{"internalType":"uint256","name":"minAmountOut","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":"exchange","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"}]

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

23016:4447:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24438:3020;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;24438:3020:0;-1:-1:-1;24438:3020:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;23140:81;;;:::i;:::-;;;;-1:-1:-1;;;;;23140:81:0;;;;;;;;;;;;;;23316:84;;;:::i;23897:533::-;;;:::i;23792:30::-;;;:::i;23228:81::-;;;:::i;23502:91::-;;;:::i;23600:88::-;;;:::i;23407:::-;;;:::i;23697:86::-;;;:::i;24438:3020::-;24825:33;;;-1:-1:-1;;;24825:33:0;;24847:10;24825:33;;;;;;24804:18;;23178:42;;24825:21;;:33;;;;;;;;;;;;;;;23178:42;24825:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;24825:33:0;24890;;;-1:-1:-1;;;24890:33:0;;24912:10;24890:33;;;;;;24825;;-1:-1:-1;24869:18:0;;23266:42;;24890:21;;:33;;;;;24825;;24890;;;;;;;23266:42;24890:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;24890:33:0;;-1:-1:-1;24982:9:0;24978:195;24997:26;;;24978:195;;;25077:1;25047:15;;25063:1;25047:18;;;;;;;;;;;;;-1:-1:-1;;;;;25047:18:0;-1:-1:-1;;;;;25047:32:0;;25044:42;;;25081:5;;25044:42;25115:15;;25131:1;25115:18;;;;;;;;;;;;;-1:-1:-1;;;;;25115:18:0;-1:-1:-1;;;;;25101:43:0;;25145:10;25156:4;25101:60;;;;;;;;;;;;;-1:-1:-1;;;;;25101:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;25025:3:0;;;;;-1:-1:-1;24978:195:0;;-1:-1:-1;24978:195:0;;;25189:9;25185:205;25204:31;;;25185:205;;;25294:1;25259:20;;25280:1;25259:23;;;;;;;;;;;;;-1:-1:-1;;;;;25259:23:0;-1:-1:-1;;;;;25259:37:0;;25256:47;;;25298:5;;25256:47;25332:20;;25353:1;25332:23;;;;;;;;;;;;;-1:-1:-1;;;;;25332:23:0;-1:-1:-1;;;;;25318:48:0;;25367:10;25318:60;;;;;;;;;;;;;-1:-1:-1;;;;;25318:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;25237:3:0;;;;;-1:-1:-1;25185:205:0;;-1:-1:-1;25185:205:0;;;25451:13;25448:199;;;25480:55;;;-1:-1:-1;;;25480:55:0;;25514:10;25480:55;;;;25525:4;25480:55;;;;;;;;;;;;23645:42;;25480:33;;:55;;;;;-1:-1:-1;;25480:55:0;;;;;;;-1:-1:-1;23645:42:0;25480:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25448:199;;;25555:8;25552:95;;;25579:56;;;-1:-1:-1;;;25579:56:0;;25613:10;25579:56;;;;25624:4;25579:56;;;;25629:5;25579:56;;;;;;;;23645:42;;25579:33;;:56;;;;;;;;;;;25629:5;23645:42;25579:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25552:95;25699:11;25696:97;;;25726:55;;;-1:-1:-1;;;25726:55:0;;25765:10;25726:55;;;;25776:4;25726:55;;;;;;23550:42;;25726:38;;:55;;;;;-1:-1:-1;;25726:55:0;;;;;;;-1:-1:-1;23550:42:0;25726:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25696:97;25859:23;;25856:1077;;25911:33;;;-1:-1:-1;;;25911:33:0;;25933:10;25911:33;;;;;;:49;;25949:10;;23178:42;;25911:21;;:33;;;;;;;;;;;;;;23178:42;25911:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;25911:33:0;;:37;:49::i;:::-;25898:62;;25988:41;25997:10;26009:19;25988:8;:41::i;:::-;25975:54;-1:-1:-1;26047:14:0;;26044:878;;26109:67;23178:42;26138:10;26158:4;26165:10;26109:28;:67::i;:::-;26198:16;;26195:474;;26290:16;;;26304:1;26290:16;;;26266:21;26290:16;;;;;26266:21;26290:16;;;;;;;;;;-1:-1:-1;26290:16:0;26266:40;;23178:42;26329:4;26334:1;26329:7;;;;;;;;;;;;;:13;-1:-1:-1;;;;;26329:13:0;;;-1:-1:-1;;;;;26329:13:0;;;;;23357:42;26365:4;26370:1;26365:7;;;;;;;;-1:-1:-1;;;;;26365:16:0;;;:7;;;;;;;;;;;:16;23740:42;26404:48;26453:10;26464:12;26477:4;26490;26496:13;:3;26504:4;26496:7;:13::i;:::-;26404:106;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;26404:106:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26195:474;;;;26588:61;;;-1:-1:-1;;;26588:61:0;;;;;;;;;;;;;;;;;23452:42;;26588:34;;:61;;;;;-1:-1:-1;;26588:61:0;;;;;;;-1:-1:-1;23452:42:0;26588:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26195:474;26744:39;;;-1:-1:-1;;;26744:39:0;;26777:4;26744:39;;;;;;26720:21;;23357:42;;26744:24;;:39;;;;;;;;;;;;;;;23357:42;26744:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;26744:39:0;26842:64;;;-1:-1:-1;;;26842:64:0;;26880:10;26842:64;;;;;;;;;;;;26744:39;;-1:-1:-1;23550:42:0;;26842:37;;:64;;;;;-1:-1:-1;;26842:64:0;;;;;;;;-1:-1:-1;23550:42:0;26842:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26044:878;;26990:23;;26987:464;;27042:33;;;-1:-1:-1;;;27042:33:0;;27064:10;27042:33;;;;;;:49;;27080:10;;23266:42;;27042:21;;:33;;;;;;;;;;;;;;23266:42;27042:33;;;;;;;;;;:49;27029:62;;27119:41;27128:10;27140:19;27119:8;:41::i;:::-;27106:54;-1:-1:-1;27178:14:0;;27175:265;;27240:67;23266:42;27269:10;27289:4;27296:10;27240:28;:67::i;:::-;27366:58;;;-1:-1:-1;;;27366:58:0;;27401:10;27366:58;;;;;;;;;;;;23645:42;;27366:34;;:58;;;;;-1:-1:-1;;27366:58:0;;;;;;;-1:-1:-1;23645:42:0;27366:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27175:265;24438:3020;;;;;;;;;;;;;:::o;23140:81::-;23178:42;23140:81;:::o;23316:84::-;23357:42;23316:84;:::o;23897:533::-;23949:10;-1:-1:-1;;;;;23963:5:0;23949:19;;23941:37;;;;;-1:-1:-1;;;23941:37:0;;;;;;;;;;;;-1:-1:-1;;;23941:37:0;;;;;;;;;;;;;;;23989:38;23178:42;23452;24025:1;23989:23;:38::i;:::-;24038:48;23178:42;23452;-1:-1:-1;;24038:23:0;:48::i;:::-;24097:36;23178:42;23740;24131:1;24097:23;:36::i;:::-;24144:46;23178:42;23740;-1:-1:-1;;24144:23:0;:46::i;:::-;24203:38;23266:42;23645;24239:1;24203:23;:38::i;:::-;24252:48;23266:42;23645;-1:-1:-1;;24252:23:0;:48::i;:::-;24313:44;23357:42;23550;24355:1;24313:26;:44::i;:::-;24368:54;23357:42;23550;-1:-1:-1;;24368:26:0;:54::i;:::-;23897:533::o;23792:30::-;;;:::o;23228:81::-;23266:42;23228:81;:::o;23502:91::-;23550:42;23502:91;:::o;23600:88::-;23645:42;23600:88;:::o;23407:::-;23452:42;23407:88;:::o;23697:86::-;23740:42;23697:86;:::o;14137:158::-;14195:7;14228:1;14223;:6;;14215:49;;;;;-1:-1:-1;;;14215:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;14282:5:0;;;14137:158::o;22225:106::-;22283:7;22314:1;22310;:5;:13;;22322:1;22310:13;;;22318:1;22310:13;22303:20;22225:106;-1:-1:-1;;;22225:106:0:o;19185:205::-;19313:68;;;-1:-1:-1;;;;;19313:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;19313:68:0;-1:-1:-1;;;19313:68:0;;;19286:96;;19306:5;;19286:19;:96::i;:::-;19185:205;;;;:::o;13675:179::-;13733:7;13765:5;;;13789:6;;;;13781:46;;;;;-1:-1:-1;;;13781:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;19659:622;20029:10;;;20028:62;;-1:-1:-1;20045:39:0;;;-1:-1:-1;;;20045:39:0;;20069:4;20045:39;;;;-1:-1:-1;;;;;20045:39:0;;;;;;;;;:15;;;;;;:39;;;;;;;;;;;;;;;:15;:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20045:39:0;:44;20028:62;20020:152;;;;-1:-1:-1;;;20020:152:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20210:62;;;-1:-1:-1;;;;;20210:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;20210:62:0;-1:-1:-1;;;20210:62:0;;;20183:90;;20203:5;;20183:19;:90::i;:::-;19659:622;;;:::o;21305:761::-;21729:23;21755:69;21783:4;21755:69;;;;;;;;;;;;;;;;;21763:5;-1:-1:-1;;;;;21755:27:0;;;:69;;;;;:::i;:::-;21839:17;;21729:95;;-1:-1:-1;21839:21:0;21835:224;;21981:10;21970:30;;;;;;;;;;;;;;;-1:-1:-1;21970:30:0;21962:85;;;;-1:-1:-1;;;21962:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3723:195;3826:12;3858:52;3880:6;3888:4;3894:1;3897:12;3858:21;:52::i;:::-;3851:59;3723:195;-1:-1:-1;;;;3723:195:0:o;4775:530::-;4902:12;4960:5;4935:21;:30;;4927:81;;;;-1:-1:-1;;;4927:81:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5027:18;5038:6;5027:10;:18::i;:::-;5019:60;;;;;-1:-1:-1;;;5019:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;5153:12;5167:23;5194:6;-1:-1:-1;;;;;5194:11:0;5214:5;5222:4;5194:33;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;5194:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5152:75;;;;5245:52;5263:7;5272:10;5284:12;5245:17;:52::i;:::-;5238:59;4775:530;-1:-1:-1;;;;;;;4775:530:0:o;805:422::-;1172:20;1211:8;;;805:422::o;7315:742::-;7430:12;7459:7;7455:595;;;-1:-1:-1;7490:10:0;7483:17;;7455:595;7604:17;;:21;7600:439;;7867:10;7861:17;7928:15;7915:10;7911:2;7907:19;7900:44;7815:148;8010:12;8003:20;;-1:-1:-1;;;8003:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

ipfs://247bc07f704ee2a9553220a53347eecbd67f4dab60a6e1aca843518b80d437bc