Contract 0x47a65e74dd6b6B5E3243dBb01EDEd9D55ba234Ad 2

/**
 *Submitted for verification at polygonscan.com on 2021-07-28
*/

// File: contracts/lib/InitializableOwnable.sol

/*

    Copyright 2020 DODO ZOO.
    SPDX-License-Identifier: Apache-2.0

*/

pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;

/**
 * @title Ownable
 * @author DODO Breeder
 *
 * @notice Ownership related functions
 */
contract InitializableOwnable {
    address public _OWNER_;
    address public _NEW_OWNER_;
    bool internal _INITIALIZED_;

    // ============ Events ============

    event OwnershipTransferPrepared(address indexed previousOwner, address indexed newOwner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    // ============ Modifiers ============

    modifier notInitialized() {
        require(!_INITIALIZED_, "DODO_INITIALIZED");
        _;
    }

    modifier onlyOwner() {
        require(msg.sender == _OWNER_, "NOT_OWNER");
        _;
    }

    // ============ Functions ============

    function initOwner(address newOwner) public notInitialized {
        _INITIALIZED_ = true;
        _OWNER_ = newOwner;
    }

    function transferOwnership(address newOwner) public onlyOwner {
        emit OwnershipTransferPrepared(_OWNER_, newOwner);
        _NEW_OWNER_ = newOwner;
    }

    function claimOwnership() public {
        require(msg.sender == _NEW_OWNER_, "INVALID_CLAIM");
        emit OwnershipTransferred(_OWNER_, _NEW_OWNER_);
        _OWNER_ = _NEW_OWNER_;
        _NEW_OWNER_ = address(0);
    }
}

// File: contracts/intf/IDODOApprove.sol

interface IDODOApprove {
    function claimTokens(address token,address who,address dest,uint256 amount) external;
    function getDODOProxy() external view returns (address);
}

// File: contracts/SmartRoute/DODOApproveProxy.sol


interface IDODOApproveProxy {
    function isAllowedProxy(address _proxy) external view returns (bool);
    function claimTokens(address token,address who,address dest,uint256 amount) external;
}

/**
 * @title DODOApproveProxy
 * @author DODO Breeder
 *
 * @notice Allow different version dodoproxy to claim from DODOApprove
 */
contract DODOApproveProxy is InitializableOwnable {
    
    // ============ Storage ============
    uint256 private constant _TIMELOCK_DURATION_ = 3 days;
    mapping (address => bool) public _IS_ALLOWED_PROXY_;
    uint256 public _TIMELOCK_;
    address public _PENDING_ADD_DODO_PROXY_;
    address public immutable _DODO_APPROVE_;

    // ============ Modifiers ============
    modifier notLocked() {
        require(
            _TIMELOCK_ <= block.timestamp,
            "SetProxy is timelocked"
        );
        _;
    }

    constructor(address dodoApporve) public {
        _DODO_APPROVE_ = dodoApporve;
    }

    function init(address owner, address[] memory proxies) external {
        initOwner(owner);
        for(uint i = 0; i < proxies.length; i++) 
            _IS_ALLOWED_PROXY_[proxies[i]] = true;
    }

    function unlockAddProxy(address newDodoProxy) public onlyOwner {
        _TIMELOCK_ = block.timestamp + _TIMELOCK_DURATION_;
        _PENDING_ADD_DODO_PROXY_ = newDodoProxy;
    }

    function lockAddProxy() public onlyOwner {
       _PENDING_ADD_DODO_PROXY_ = address(0);
       _TIMELOCK_ = 0;
    }


    function addDODOProxy() external onlyOwner notLocked() {
        _IS_ALLOWED_PROXY_[_PENDING_ADD_DODO_PROXY_] = true;
        lockAddProxy();
    }

    function removeDODOProxy (address oldDodoProxy) public onlyOwner {
        _IS_ALLOWED_PROXY_[oldDodoProxy] = false;
    }
    
    function claimTokens(
        address token,
        address who,
        address dest,
        uint256 amount
    ) external {
        require(_IS_ALLOWED_PROXY_[msg.sender], "DODOApproveProxy:Access restricted");
        IDODOApprove(_DODO_APPROVE_).claimTokens(
            token,
            who,
            dest,
            amount
        );
    }

    function isAllowedProxy(address _proxy) external view returns (bool) {
        return _IS_ALLOWED_PROXY_[_proxy];
    }
}

// File: contracts/lib/Ownable.sol

/**
 * @title Ownable
 * @author DODO Breeder
 *
 * @notice Ownership related functions
 */
contract Ownable {
    address public _OWNER_;
    address public _NEW_OWNER_;

    // ============ Events ============

    event OwnershipTransferPrepared(address indexed previousOwner, address indexed newOwner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    // ============ Modifiers ============

    modifier onlyOwner() {
        require(msg.sender == _OWNER_, "NOT_OWNER");
        _;
    }

    // ============ Functions ============

    constructor() internal {
        _OWNER_ = msg.sender;
        emit OwnershipTransferred(address(0), _OWNER_);
    }

    function transferOwnership(address newOwner) external virtual onlyOwner {
        emit OwnershipTransferPrepared(_OWNER_, newOwner);
        _NEW_OWNER_ = newOwner;
    }

    function claimOwnership() external {
        require(msg.sender == _NEW_OWNER_, "INVALID_CLAIM");
        emit OwnershipTransferred(_OWNER_, _NEW_OWNER_);
        _OWNER_ = _NEW_OWNER_;
        _NEW_OWNER_ = address(0);
    }
}

// File: contracts/intf/IERC20.sol

/**
 * @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);

    function decimals() external view returns (uint8);

    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

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

// File: contracts/lib/SafeMath.sol

/**
 * @title SafeMath
 * @author DODO Breeder
 *
 * @notice Math operations with safety checks that revert on error
 */
library SafeMath {
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "MUL_ERROR");

        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "DIVIDING_ERROR");
        return a / b;
    }

    function divCeil(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 quotient = div(a, b);
        uint256 remainder = a - quotient * b;
        if (remainder > 0) {
            return quotient + 1;
        } else {
            return quotient;
        }
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SUB_ERROR");
        return a - b;
    }

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "ADD_ERROR");
        return c;
    }

    function sqrt(uint256 x) internal pure returns (uint256 y) {
        uint256 z = x / 2 + 1;
        y = x;
        while (z < y) {
            y = z;
            z = (x / z + z) / 2;
        }
    }
}

// File: contracts/lib/SafeERC20.sol



/**
 * @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 ERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;

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

    /**
     * @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.

        // A Solidity high level call has three parts:
        //  1. The target address is checked to verify it contains contract code
        //  2. The call itself is made, and success asserted
        //  3. The return value is decoded, which in turn checks the size of the returned data.
        // solhint-disable-next-line max-line-length

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

// File: contracts/DODOToken/DODOMineV3/RewardVault.sol


interface IRewardVault {
    function reward(address to, uint256 amount) external;
    function withdrawLeftOver(address to, uint256 amount) external; 
    function syncValue() external;
    function _TOTAL_REWARD_() external view returns(uint256);
}

contract RewardVault is Ownable {
    using SafeERC20 for IERC20;
    using SafeMath for uint256;

    uint256 public _REWARD_RESERVE_;
    uint256 public _TOTAL_REWARD_;
    address public _REWARD_TOKEN_;

    // ============ Event =============
    event DepositReward(uint256 totalReward, uint256 inputReward, uint256 rewardReserve);

    constructor(address _rewardToken) public {
        _REWARD_TOKEN_ = _rewardToken;
    }

    function reward(address to, uint256 amount) external onlyOwner {
        require(_REWARD_RESERVE_ >= amount, "VAULT_NOT_ENOUGH");
        _REWARD_RESERVE_ = _REWARD_RESERVE_.sub(amount);
        IERC20(_REWARD_TOKEN_).safeTransfer(to, amount);
    }

    function withdrawLeftOver(address to,uint256 amount) external onlyOwner {
        require(_REWARD_RESERVE_ >= amount, "VAULT_NOT_ENOUGH");
        _REWARD_RESERVE_ = _REWARD_RESERVE_.sub(amount);
        IERC20(_REWARD_TOKEN_).safeTransfer(to, amount);
    }

    function syncValue() external {
        uint256 rewardBalance = IERC20(_REWARD_TOKEN_).balanceOf(address(this));
        uint256 rewardInput = rewardBalance.sub(_REWARD_RESERVE_);

        _TOTAL_REWARD_ = _TOTAL_REWARD_.add(rewardInput);
        _REWARD_RESERVE_ = rewardBalance;

        emit DepositReward(_TOTAL_REWARD_, rewardInput, _REWARD_RESERVE_);
    }
}

// File: contracts/Factory/Registries/DODOMineV3Registry.sol


interface IDODOMineV3Registry {
    function addMineV3(
        address mine,
        bool isLpToken,
        address stakeToken
    ) external;
}

/**
 * @title DODOMineV3 Registry
 * @author DODO Breeder
 *
 * @notice Register DODOMineV3 Pools 
 */
contract DODOMineV3Registry is InitializableOwnable, IDODOMineV3Registry {

    mapping (address => bool) public isAdminListed;
    
    // ============ Registry ============
    // minePool -> stakeToken
    mapping(address => address) public _MINE_REGISTRY_;
    // lpToken -> minePool
    mapping(address => address[]) public _LP_REGISTRY_;
    // singleToken -> minePool
    mapping(address => address[]) public _SINGLE_REGISTRY_;


    // ============ Events ============
    event NewMineV3(address mine, address stakeToken, bool isLpToken);
    event RemoveMineV3(address mine, address stakeToken);
    event addAdmin(address admin);
    event removeAdmin(address admin);


    function addMineV3(
        address mine,
        bool isLpToken,
        address stakeToken
    ) override external {
        require(isAdminListed[msg.sender], "ACCESS_DENIED");
        _MINE_REGISTRY_[mine] = stakeToken;
        if(isLpToken) {
            _LP_REGISTRY_[stakeToken].push(mine);
        }else {
            _SINGLE_REGISTRY_[stakeToken].push(mine);
        }

        emit NewMineV3(mine, stakeToken, isLpToken);
    }

    // ============ Admin Operation Functions ============

    function removeMineV3(
        address mine,
        bool isLpToken,
        address stakeToken
    ) external onlyOwner {
        _MINE_REGISTRY_[mine] = address(0);
        if(isLpToken) {
            uint256 len = _LP_REGISTRY_[stakeToken].length;
            for (uint256 i = 0; i < len; i++) {
                if (mine == _LP_REGISTRY_[stakeToken][i]) {
                    if(i != len - 1) {
                        _LP_REGISTRY_[stakeToken][i] = _LP_REGISTRY_[stakeToken][len - 1];
                    }
                    _LP_REGISTRY_[stakeToken].pop();
                    break;
                }
            }
        }else {
            uint256 len = _SINGLE_REGISTRY_[stakeToken].length;
            for (uint256 i = 0; i < len; i++) {
                if (mine == _SINGLE_REGISTRY_[stakeToken][i]) {
                    if(i != len - 1) {
                        _SINGLE_REGISTRY_[stakeToken][i] = _SINGLE_REGISTRY_[stakeToken][len - 1];
                    }
                    _SINGLE_REGISTRY_[stakeToken].pop();
                    break;
                }
            }
        }

        emit RemoveMineV3(mine, stakeToken);
    }

    function addAdminList (address contractAddr) external onlyOwner {
        isAdminListed[contractAddr] = true;
        emit addAdmin(contractAddr);
    }

    function removeAdminList (address contractAddr) external onlyOwner {
        isAdminListed[contractAddr] = false;
        emit removeAdmin(contractAddr);
    }
}

// File: contracts/lib/CloneFactory.sol

interface ICloneFactory {
    function clone(address prototype) external returns (address proxy);
}

// introduction of proxy mode design: https://docs.openzeppelin.com/upgrades/2.8/
// minimum implementation of transparent proxy: https://eips.ethereum.org/EIPS/eip-1167

contract CloneFactory is ICloneFactory {
    function clone(address prototype) external override returns (address proxy) {
        bytes20 targetBytes = bytes20(prototype);
        assembly {
            let clone := mload(0x40)
            mstore(clone, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
            mstore(add(clone, 0x14), targetBytes)
            mstore(
                add(clone, 0x28),
                0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000
            )
            proxy := create(0, clone, 0x37)
        }
        return proxy;
    }
}

// File: contracts/SmartRoute/proxies/DODOMineV3Proxy.sol

interface IMineV3 {
    function init(address owner, address token) external;

    function addRewardToken(
        address rewardToken,
        uint256 rewardPerBlock,
        uint256 startBlock,
        uint256 endBlock
    ) external;

    function directTransferOwnership(address newOwner) external;

    function getVaultByRewardToken(address rewardToken) external view returns(address);
}

/**
 * @title DODOMineV3 Proxy
 * @author DODO Breeder
 *
 * @notice Create And Register DODOMineV3 Contracts 
 */
contract DODOMineV3Proxy is InitializableOwnable {
    using SafeMath for uint256;
    // ============ Templates ============

    address public immutable _CLONE_FACTORY_;
    address public immutable _DODO_APPROVE_PROXY_;
    address public immutable _DODO_MINEV3_REGISTRY_;
    address public _MINEV3_TEMPLATE_;


    // ============ Events ============
    event DepositRewardToVault(address mine, address rewardToken, uint256 amount);
    event DepositRewardToMine(address mine, address rewardToken, uint256 amount);
    event CreateMineV3(address account, address mineV3);
    event ChangeMineV3Template(address mineV3);

    constructor(
        address cloneFactory,
        address mineTemplate,
        address dodoApproveProxy,
        address dodoMineV3Registry
    ) public {
        _CLONE_FACTORY_ = cloneFactory;
        _MINEV3_TEMPLATE_ = mineTemplate;
        _DODO_APPROVE_PROXY_ = dodoApproveProxy;
        _DODO_MINEV3_REGISTRY_ = dodoMineV3Registry;
    }

    // ============ Functions ============

    function createDODOMineV3(
        address stakeToken,
        bool isLpToken,
        address[] memory rewardTokens,
        uint256[] memory rewardPerBlock,
        uint256[] memory startBlock,
        uint256[] memory endBlock
    ) external returns (address newMineV3) {
        require(rewardTokens.length > 0, "REWARD_EMPTY");
        require(rewardTokens.length == rewardPerBlock.length, "REWARD_PARAM_NOT_MATCH");
        require(startBlock.length == rewardPerBlock.length, "REWARD_PARAM_NOT_MATCH");
        require(endBlock.length == rewardPerBlock.length, "REWARD_PARAM_NOT_MATCH");

        newMineV3 = ICloneFactory(_CLONE_FACTORY_).clone(_MINEV3_TEMPLATE_);

        IMineV3(newMineV3).init(address(this), stakeToken);

        for(uint i = 0; i<rewardTokens.length; i++) {
            uint256 rewardAmount = rewardPerBlock[i].mul(endBlock[i].sub(startBlock[i]));
            IDODOApproveProxy(_DODO_APPROVE_PROXY_).claimTokens(rewardTokens[i], msg.sender, newMineV3, rewardAmount);
            IMineV3(newMineV3).addRewardToken(
                rewardTokens[i],
                rewardPerBlock[i],
                startBlock[i],
                endBlock[i]
            );
        }

        IMineV3(newMineV3).directTransferOwnership(msg.sender);

        IDODOMineV3Registry(_DODO_MINEV3_REGISTRY_).addMineV3(newMineV3, isLpToken, stakeToken);

        emit CreateMineV3(msg.sender, newMineV3);
    }

    function depositRewardToVault(
        address mineV3,
        address rewardToken,
        uint256 amount
    ) external {    
        address rewardVault = IMineV3(mineV3).getVaultByRewardToken(rewardToken);
        IDODOApproveProxy(_DODO_APPROVE_PROXY_).claimTokens(rewardToken, msg.sender, rewardVault, amount);
        IRewardVault(rewardVault).syncValue();

        emit DepositRewardToVault(mineV3,rewardToken,amount);
    }

    function depositRewardToMine(
        address mineV3,
        address rewardToken,
        uint256 amount
    ) external {
        require(mineV3 != address(0), "MINE_EMPTY");
        IDODOApproveProxy(_DODO_APPROVE_PROXY_).claimTokens(rewardToken, msg.sender, mineV3, amount);

        emit DepositRewardToMine(mineV3,rewardToken,amount);
    }

    // ============ Admin Operation Functions ============
    
    function updateMineV3Template(address _newMineV3Template) external onlyOwner {
        _MINEV3_TEMPLATE_ = _newMineV3Template;
        emit ChangeMineV3Template(_newMineV3Template);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"cloneFactory","type":"address"},{"internalType":"address","name":"mineTemplate","type":"address"},{"internalType":"address","name":"dodoApproveProxy","type":"address"},{"internalType":"address","name":"dodoMineV3Registry","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"mineV3","type":"address"}],"name":"ChangeMineV3Template","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"address","name":"mineV3","type":"address"}],"name":"CreateMineV3","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"mine","type":"address"},{"indexed":false,"internalType":"address","name":"rewardToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"DepositRewardToMine","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"mine","type":"address"},{"indexed":false,"internalType":"address","name":"rewardToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"DepositRewardToVault","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferPrepared","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"_CLONE_FACTORY_","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_DODO_APPROVE_PROXY_","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_DODO_MINEV3_REGISTRY_","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_MINEV3_TEMPLATE_","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_NEW_OWNER_","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":"claimOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"stakeToken","type":"address"},{"internalType":"bool","name":"isLpToken","type":"bool"},{"internalType":"address[]","name":"rewardTokens","type":"address[]"},{"internalType":"uint256[]","name":"rewardPerBlock","type":"uint256[]"},{"internalType":"uint256[]","name":"startBlock","type":"uint256[]"},{"internalType":"uint256[]","name":"endBlock","type":"uint256[]"}],"name":"createDODOMineV3","outputs":[{"internalType":"address","name":"newMineV3","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"mineV3","type":"address"},{"internalType":"address","name":"rewardToken","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"depositRewardToMine","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"mineV3","type":"address"},{"internalType":"address","name":"rewardToken","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"depositRewardToVault","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"initOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newMineV3Template","type":"address"}],"name":"updateMineV3Template","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000729f7f44bf64ce814716b6261e267dbe6cdf021c00000000000000000000000053a51a124efcda74fc607a272615e7e93f661a9400000000000000000000000001feea29da5ae41b0b5f6b10b93ee34752ef80d700000000000000000000000027566bf9504466f6f3a1571e1863da42fff4d25e

-----Decoded View---------------
Arg [0] : cloneFactory (address): 0x729f7f44bf64ce814716b6261e267dbe6cdf021c
Arg [1] : mineTemplate (address): 0x53a51a124efcda74fc607a272615e7e93f661a94
Arg [2] : dodoApproveProxy (address): 0x01feea29da5ae41b0b5f6b10b93ee34752ef80d7
Arg [3] : dodoMineV3Registry (address): 0x27566bf9504466f6f3a1571e1863da42fff4d25e

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 000000000000000000000000729f7f44bf64ce814716b6261e267dbe6cdf021c
Arg [1] : 00000000000000000000000053a51a124efcda74fc607a272615e7e93f661a94
Arg [2] : 00000000000000000000000001feea29da5ae41b0b5f6b10b93ee34752ef80d7
Arg [3] : 00000000000000000000000027566bf9504466f6f3a1571e1863da42fff4d25e

18670:3585:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;965:127;;;;;;;;;:::i;:::-;;332:22;;;:::i;:::-;;;;;;;;;;;;;;;;18904:47;;;:::i;1271:228::-;;;:::i;22062:190::-;;;;;;;;;:::i;18958:32::-;;;:::i;361:26::-;;;:::i;21184:442::-;;;;;;;;;:::i;19728:1448::-;;;;;;;;;:::i;21634:354::-;;;;;;;;;:::i;18805:40::-;;;:::i;18852:45::-;;;:::i;1100:163::-;;;;;;;;;:::i;965:127::-;754:13;;-1:-1:-1;;;754:13:0;;;;753:14;745:43;;;;-1:-1:-1;;;745:43:0;;;;;;;;;;;;;;;;;1051:4:::1;1035:20:::0;;-1:-1:-1;;;;1035:20:0::1;-1:-1:-1::0;;;1035:20:0::1;::::0;;;1066:18;;-1:-1:-1;;;;;1066:18:0;;::::1;-1:-1:-1::0;;;;;;1066:18:0;;::::1;::::0;;;::::1;::::0;;965:127::o;332:22::-;;;-1:-1:-1;;;;;332:22:0;;:::o;18904:47::-;;;:::o;1271:228::-;1337:11;;-1:-1:-1;;;;;1337:11:0;1323:10;:25;1315:51;;;;-1:-1:-1;;;1315:51:0;;;;;;;;;1412:11;;;1403:7;;1382:42;;-1:-1:-1;;;;;1412:11:0;;;;1403:7;;;;1382:42;;;1445:11;;;;1435:21;;-1:-1:-1;;;;;;1435:21:0;;;-1:-1:-1;;;;;1445:11:0;;1435:21;;;;1467:24;;;1271:228::o;22062:190::-;870:7;;-1:-1:-1;;;;;870:7:0;856:10;:21;848:43;;;;-1:-1:-1;;;848:43:0;;;;;;;;;22150:17:::1;:38:::0;;-1:-1:-1;;;;;;22150:38:0::1;-1:-1:-1::0;;;;;22150:38:0;::::1;;::::0;;22204:40:::1;::::0;::::1;::::0;::::1;::::0;22150:38;;22204:40:::1;;;;;;;;;;22062:190:::0;:::o;18958:32::-;;;-1:-1:-1;;;;;18958:32:0;;:::o;361:26::-;;;-1:-1:-1;;;;;361:26:0;;:::o;21184:442::-;21347:50;;-1:-1:-1;;;21347:50:0;;21325:19;;-1:-1:-1;;;;;21347:37:0;;;;;:50;;21385:11;;21347:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21408:97;;-1:-1:-1;;;21408:97:0;;21325:72;;-1:-1:-1;;;;;;21426:20:0;21408:51;;;;:97;;21460:11;;21473:10;;21325:72;;21498:6;;21408:97;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21529:11;-1:-1:-1;;;;;21516:35:0;;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21571:47;21592:6;21599:11;21611:6;21571:47;;;;;;;;;;;;;;;;;21184:442;;;;:::o;19728:1448::-;19989:17;20049:1;20027:12;:19;:23;20019:48;;;;-1:-1:-1;;;20019:48:0;;;;;;;;;20109:14;:21;20086:12;:19;:44;20078:79;;;;-1:-1:-1;;;20078:79:0;;;;;;;;;20197:14;:21;20176:10;:17;:42;20168:77;;;;-1:-1:-1;;;20168:77:0;;;;;;;;;20283:14;:21;20264:8;:15;:40;20256:75;;;;-1:-1:-1;;;20256:75:0;;;;;;;;;20393:17;;20356:55;;-1:-1:-1;;;20356:55:0;;-1:-1:-1;;;;;20370:15:0;20356:36;;;;;:55;;20393:17;;;;;20356:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20424:50;;-1:-1:-1;;;20424:50:0;;20344:67;;-1:-1:-1;;;;;;20424:23:0;;;;;:50;;20456:4;;20463:10;;20424:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20491:6:0;;-1:-1:-1;;;20487:462:0;20505:12;:19;20503:1;:21;20487:462;;;20546:20;20569:53;20591:30;20607:10;20618:1;20607:13;;;;;;;;;;;;;;20591:8;20600:1;20591:11;;;;;;;;;;;;;;:15;;:30;;;;:::i;:::-;20569:14;20584:1;20569:17;;;;;;;;;;;;;;:21;;:53;;;;:::i;:::-;20546:76;;20655:20;-1:-1:-1;;;;;20637:51:0;;20689:12;20702:1;20689:15;;;;;;;;;;;;;;20706:10;20718:9;20729:12;20637:105;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20765:9;-1:-1:-1;;;;;20757:33:0;;20809:12;20822:1;20809:15;;;;;;;;;;;;;;20843:14;20858:1;20843:17;;;;;;;;;;;;;;20879:10;20890:1;20879:13;;;;;;;;;;;;;;20911:8;20920:1;20911:11;;;;;;;;;;;;;;20757:180;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;20526:3:0;;;;;-1:-1:-1;20487:462:0;;-1:-1:-1;;20487:462:0;;-1:-1:-1;20961:54:0;;-1:-1:-1;;;20961:54:0;;-1:-1:-1;;;;;20961:42:0;;;;;:54;;21004:10;;20961:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;21028:87:0;;-1:-1:-1;;;21028:87:0;;-1:-1:-1;;;;;21048:22:0;21028:53;;-1:-1:-1;21028:53:0;;-1:-1:-1;21028:87:0;;21082:9;;21093;;21104:10;;21028:87;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21133:35;21146:10;21158:9;21133:35;;;;;;;;;;;;;;;;19728:1448;;;;;;;;:::o;21634:354::-;-1:-1:-1;;;;;21778:20:0;;21770:43;;;;-1:-1:-1;;;21770:43:0;;;;;;;;;21824:92;;-1:-1:-1;;;21824:92:0;;-1:-1:-1;;;;;21842:20:0;21824:51;;;;:92;;21876:11;;21889:10;;21901:6;;21909;;21824:92;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21934:46;21954:6;21961:11;21973:6;21934:46;;;;;;;;;;;;;;;;;21634:354;;;:::o;18805:40::-;;;:::o;18852:45::-;;;:::o;1100:163::-;870:7;;-1:-1:-1;;;;;870:7:0;856:10;:21;848:43;;;;-1:-1:-1;;;848:43:0;;;;;;;;;1204:7:::1;::::0;;1178:44:::1;::::0;-1:-1:-1;;;;;1178:44:0;;::::1;::::0;1204:7;::::1;::::0;1178:44:::1;::::0;::::1;1233:11;:22:::0;;-1:-1:-1;;;;;;1233:22:0::1;-1:-1:-1::0;;;;;1233:22:0;;;::::1;::::0;;;::::1;::::0;;1100:163::o;8649:137::-;8707:7;8740:1;8735;:6;;8727:28;;;;-1:-1:-1;;;8727:28:0;;;;;;;;;-1:-1:-1;8773:5:0;;;8649:137;;;;;:::o;7970:226::-;8028:7;8052:6;8048:47;;-1:-1:-1;8082:1:0;8075:8;;8048:47;8119:5;;;8123:1;8119;:5;:1;8143:5;;;;;:10;8135:32;;;;-1:-1:-1;;;8135:32:0;;;;;;;;;8187:1;7970:226;-1:-1:-1;;;7970:226:0:o;5:130:-1:-;72:20;;97:33;72:20;97:33;;301:707;;418:3;411:4;403:6;399:17;395:27;385:2;;-1:-1;;426:12;385:2;473:6;460:20;495:80;510:64;567:6;510:64;;;495:80;;;603:21;;;486:89;-1:-1;647:4;660:14;;;;635:17;;;749;;;740:27;;;;737:36;-1:-1;734:2;;;786:1;;776:12;734:2;811:1;796:206;821:6;818:1;815:13;796:206;;;85:6;72:20;97:33;124:5;97:33;;;889:50;;953:14;;;;981;;;;843:1;836:9;796:206;;;800:14;;;;;378:630;;;;;1034:707;;1151:3;1144:4;1136:6;1132:17;1128:27;1118:2;;-1:-1;;1159:12;1118:2;1206:6;1193:20;1228:80;1243:64;1300:6;1243:64;;1228:80;1336:21;;;1219:89;-1:-1;1380:4;1393:14;;;;1368:17;;;1482;;;1473:27;;;;1470:36;-1:-1;1467:2;;;1519:1;;1509:12;1467:2;1544:1;1529:206;1554:6;1551:1;1548:13;1529:206;;;1947:20;;1622:50;;1686:14;;;;1714;;;;1576:1;1569:9;1529:206;;1749:124;1813:20;;15323:13;;15316:21;16115:32;;16105:2;;16161:1;;16151:12;2017:241;;2121:2;2109:9;2100:7;2096:23;2092:32;2089:2;;;-1:-1;;2127:12;2089:2;85:6;72:20;97:33;124:5;97:33;;2265:263;;2380:2;2368:9;2359:7;2355:23;2351:32;2348:2;;;-1:-1;;2386:12;2348:2;226:6;220:13;238:33;265:5;238:33;;2535:491;;;;2673:2;2661:9;2652:7;2648:23;2644:32;2641:2;;;-1:-1;;2679:12;2641:2;85:6;72:20;97:33;124:5;97:33;;;2731:63;-1:-1;2831:2;2870:22;;72:20;97:33;72:20;97:33;;;2635:391;;2839:63;;-1:-1;;;2939:2;2978:22;;;;1947:20;;2635:391;3033:1407;;;;;;;3319:3;3307:9;3298:7;3294:23;3290:33;3287:2;;;-1:-1;;3326:12;3287:2;3388:53;3433:7;3409:22;3388:53;;;3378:63;;3496:50;3538:7;3478:2;3518:9;3514:22;3496:50;;;3486:60;;3611:2;3600:9;3596:18;3583:32;3635:18;;3627:6;3624:30;3621:2;;;-1:-1;;3657:12;3621:2;3687:78;3757:7;3748:6;3737:9;3733:22;3687:78;;;3677:88;;3830:2;3819:9;3815:18;3802:32;3788:46;;3635:18;3846:6;3843:30;3840:2;;;-1:-1;;3876:12;3840:2;3906:78;3976:7;3967:6;3956:9;3952:22;3906:78;;;3896:88;;4049:3;4038:9;4034:19;4021:33;4007:47;;3635:18;4066:6;4063:30;4060:2;;;-1:-1;;4096:12;4060:2;4126:78;4196:7;4187:6;4176:9;4172:22;4126:78;;;4116:88;;4269:3;4258:9;4254:19;4241:33;4227:47;;3635:18;4286:6;4283:30;4280:2;;;-1:-1;;4316:12;4280:2;;4346:78;4416:7;4407:6;4396:9;4392:22;4346:78;;;4336:88;;;3281:1159;;;;;;;;;7516:222;-1:-1;;;;;15411:54;;;;4667:37;;7643:2;7628:18;;7614:124;7990:349;-1:-1;;;;;15411:54;;;4526:58;;15411:54;;8325:2;8310:18;;4667:37;8153:2;8138:18;;8124:215;8686:572;-1:-1;;;;;15411:54;;;4667:37;;15411:54;;;9078:2;9063:18;;4526:58;15411:54;;9161:2;9146:18;;4667:37;9244:2;9229:18;;7467:37;;;;8905:3;8890:19;;8876:382;9265:444;-1:-1;;;;;15411:54;;;4667:37;;15411:54;;;;9612:2;9597:18;;4667:37;9695:2;9680:18;;7467:37;;;;9448:2;9433:18;;9419:290;9716:432;-1:-1;;;;;15411:54;;;4667:37;;15323:13;;15316:21;10051:2;10036:18;;4781:34;15411:54;;;10134:2;10119:18;;4667:37;9893:2;9878:18;;9864:284;10155:556;-1:-1;;;;;15411:54;;;;4667:37;;10531:2;10516:18;;7467:37;;;;10614:2;10599:18;;7467:37;10697:2;10682:18;;7467:37;10366:3;10351:19;;10337:374;10718:416;10918:2;10932:47;;;5052:2;10903:18;;;15091:19;-1:-1;;;15131:14;;;5068:36;5123:12;;;10889:245;11141:416;11341:2;11355:47;;;5374:1;11326:18;;;15091:19;-1:-1;;;15131:14;;;5389:32;5440:12;;;11312:245;11564:416;11764:2;11778:47;;;5691:2;11749:18;;;15091:19;-1:-1;;;15131:14;;;5707:39;5765:12;;;11735:245;11987:416;12187:2;12201:47;;;6016:2;12172:18;;;15091:19;-1:-1;;;15131:14;;;6032:35;6086:12;;;12158:245;12410:416;12610:2;12624:47;;;6337:2;12595:18;;;15091:19;-1:-1;;;15131:14;;;6353:45;6417:12;;;12581:245;12833:416;13033:2;13047:47;;;6668:1;13018:18;;;15091:19;-1:-1;;;15131:14;;;6683:32;6734:12;;;13004:245;13256:416;13456:2;13470:47;;;6985:2;13441:18;;;15091:19;-1:-1;;;15131:14;;;7001:33;7053:12;;;13427:245;13679:416;13879:2;13893:47;;;7304:1;13864:18;;;15091:19;-1:-1;;;15131:14;;;7319:32;7370:12;;;13850:245;14102:256;14164:2;14158:9;14190:17;;;14265:18;14250:34;;14286:22;;;14247:62;14244:2;;;14322:1;;14312:12;14244:2;14164;14331:22;14142:216;;-1:-1;14142:216;14365:304;;14524:18;14516:6;14513:30;14510:2;;;-1:-1;;14546:12;14510:2;-1:-1;14591:4;14579:17;;;14644:15;;14447:222;15935:117;-1:-1;;;;;15411:54;;15994:35;;15984:2;;16043:1;;16033:12;15984:2;15978:74;

ipfs://0ff7cbddb5dc37fee37d8be302832eb71bb716f258ec80094a634c2342ff717c