Contract 0x9c9c920e51778c4abf727b8bb223e78132f00aa4 5

// SPDX-License-Identifier: MIT

pragma solidity 0.8.10;

import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
import "@openzeppelin/contracts/utils/math/SafeCast.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IRewarder.sol";
import "./interfaces/IMasterChef.sol";
import "./utils/SpookyAuth.sol";
import "./utils/Multicall.sol";
import "./utils/SelfPermit.sol";


/// @notice The (older) MasterChef contract gives out a constant number of BOO tokens per second.
/// It is the only address with minting rights for BOO.
/// The idea for this MasterChef V2 (MCV2) contract is therefore to be the owner of a dummy token
/// that is deposited into the MasterChef V1 (MCV1) contract.
/// The allocation point for this pool on MCV1 is the total allocation point for all pools that receive double incentives.
contract MasterChefV2 is SpookyAuth, SelfPermit, Multicall, ReentrancyGuard {
    using SafeERC20 for IERC20;
    using SafeCast for uint;

    /// @notice Info of each MCV2 user.
    /// `amount` LP token amount the user has provided.
    /// `rewardDebt`
    struct UserInfo {
        uint amount;
        uint rewardDebt;
    }

    /// @notice Info of each MCV2 pool.
    /// `allocPoint` The amount of allocation points assigned to the pool.
    /// Also known as the amount of BOO to distribute per second.
    struct PoolInfo {
        uint128 accBooPerShare;
        uint64 lastRewardTime;
        uint64 allocPoint;
    }

    /// @notice Address of MCV1 contract.
    IMasterChef public immutable MASTER_CHEF;
    /// @notice Address of BOO contract.
    IERC20 public immutable BOO;
    /// @notice The index of MCV2 master pool in MCV1.
    uint public immutable MASTER_PID;

    /// @notice Info of each MCV2 pool.
    mapping (uint => PoolInfo) public poolInfo;
    /// @notice Address of the LP token for each MCV2 pool.
    mapping (uint => IERC20) public lpToken;
    /// @notice Amount of pool infos and their respective lpToken entries I.E stores last ID + 1, for above two mappings
    uint public poolInfoAmount;
    /// @notice Is an address contained in the above `lpToken` array
    mapping(IERC20 => bool) public isLpToken;
    /// @notice Address of each `IRewarder` contract in MCV2.
    mapping(uint => IRewarder) public rewarder;
    mapping(uint => uint) public lpSupplies;

    /// @notice Info of each user that stakes LP tokens.
    mapping (uint => mapping (address => UserInfo)) public userInfo;
    /// @dev Total allocation points. Must be the sum of all allocation points in all pools.
    uint public totalAllocPoint;

    uint private constant ACC_BOO_PRECISION = 1e12;

    /// @dev Last MCV1 harvest timestamp.
    uint public lastV1HarvestTimestamp;
    /// @dev How often v1 harvest should be called by the query function
    uint public V1_HARVEST_QUERY_TIME = 1 days;

    event Deposit(address indexed user, uint indexed pid, uint amount, address indexed to);
    event Withdraw(address indexed user, uint indexed pid, uint amount, address indexed to);
    event EmergencyWithdraw(address indexed user, uint indexed pid, uint amount, address indexed to);
    event Harvest(address indexed user, uint indexed pid, uint amount);
    event LogPoolAddition(uint indexed pid, uint allocPoint, IERC20 indexed lpToken, IRewarder rewarder, bool update);
    event LogSetPool(uint indexed pid, uint allocPoint, IRewarder rewarder, bool overwrite, bool update);
    event LogUpdatePool(uint indexed pid, uint lastRewardTime, uint lpSupply, uint accBooPerShare);
    event LogInit();

    /// @param _MASTER_CHEF The SpookySwap MCV1 contract address.
    /// @param _boo The BOO token contract address.
    /// @param _MASTER_PID The pool ID of the dummy token on the base MCV1 contract.
    constructor(IMasterChef _MASTER_CHEF, IERC20 _boo, uint _MASTER_PID) {
        MASTER_CHEF = _MASTER_CHEF;
        BOO = _boo;
        MASTER_PID = _MASTER_PID;
    }

    /// @notice Deposits a dummy token to `MASTER_CHEF` MCV1. This is required because MCV1 holds the minting rights for BOO.
    /// Any balance of transaction sender in `dummyToken` is transferred.
    /// The allocation point for the pool on MCV1 can be the total allocation point for all pools on mcv2
    /// @param dummyToken The address of the ERC-20 token to deposit into MCV1.
    function init(IERC20 dummyToken) external {
        uint balance = dummyToken.balanceOf(msg.sender);
        require(balance != 0, "MasterChefV2: Balance must exceed 0");
        dummyToken.safeTransferFrom(msg.sender, address(this), balance);
        dummyToken.approve(address(MASTER_CHEF), balance);
        MASTER_CHEF.deposit(MASTER_PID, balance);
        emit LogInit();
    }

    /// @notice Returns the number of MCV2 pools.
    function poolLength() external view returns (uint pools) {
        pools = poolInfoAmount;
    }

    function checkForDuplicate(IERC20 _lpToken) internal view {
        require(!isLpToken[_lpToken], "add: pool already exists!!!!");
    }

    function getFarmData(uint pid) external view returns (PoolInfo memory, uint, IRewarder) {
        return (poolInfo[pid], totalAllocPoint, rewarder[pid]);
    }

    modifier validatePid(uint256 pid) {
        require(pid < poolInfoAmount, "pid doesn't exist...");
        _;
    }

    

    /// @notice View function to see pending BOO on frontend.
    /// @param _pid The index of the pool. See `poolInfo`.
    /// @param _user Address of user.
    /// @return pending BOO reward for a given user.
    function pendingBOO(uint _pid, address _user) external view validatePid(_pid) returns (uint pending) {
        PoolInfo memory pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint accBooPerShare = pool.accBooPerShare;
        uint lpSupply = lpSupplies[_pid];
        if (block.timestamp > pool.lastRewardTime && lpSupply != 0) {
            uint multiplier = block.timestamp - pool.lastRewardTime;
            uint booReward = totalAllocPoint == 0 ? 0 : ((multiplier * booPerSecond() * pool.allocPoint) / totalAllocPoint);
            accBooPerShare = accBooPerShare + (booReward * ACC_BOO_PRECISION / lpSupply);
        }
        pending = (user.amount * accBooPerShare / ACC_BOO_PRECISION) - user.rewardDebt;
    }

    /// @notice Update reward variables for an array of pools. Be careful of gas spending!
    /// @param pids Pool IDs of all to be updated. Make sure to update all active pools.
    function massUpdatePools(uint256[] calldata pids) external {
        harvestFromMasterChef();
        uint256 len = pids.length;
        for (uint256 i = 0; i < len; ++i) {
            _updatePool(pids[i]);
        }
    }

    /// @notice Update reward variables for all pools. Be careful of gas spending!
    /// @dev This function should never be called from a smart contract as it has an unbounded gas cost.
    function massUpdateAllPools() public {
        harvestFromMasterChef();
        uint len = poolInfoAmount;
        for (uint pid = 0; pid < len; ++pid) {
            _updatePool(pid);
        }
    }

    /// @notice Calculates and returns the `amount` of BOO per second allocated to this contract
    function booPerSecond() public view returns (uint amount) {
        uint totalAlloc = MASTER_CHEF.totalAllocPoint();
        if(totalAlloc > 0)
            amount = MASTER_CHEF.booPerSecond() * MASTER_CHEF.poolInfo(MASTER_PID).allocPoint / totalAlloc;
        else
            amount = 0;
    }

    /// @notice Update reward variables of the given pool.
    /// @param pid The index of the pool. See `poolInfo`.
    /// @return pool Returns the pool that was updated.
    function _updatePool(uint pid) internal validatePid(pid) returns (PoolInfo memory pool) {
        pool = poolInfo[pid];
        if (block.timestamp > pool.lastRewardTime) {
            uint lpSupply = lpSupplies[pid];
            if (lpSupply > 0) {
                uint multiplier = block.timestamp - pool.lastRewardTime;
                uint booReward = totalAllocPoint == 0 ? 0 : ((multiplier * booPerSecond() * pool.allocPoint) / totalAllocPoint);
                queryHarvestFromMasterChef();
                pool.accBooPerShare = (pool.accBooPerShare + ((booReward * ACC_BOO_PRECISION) / lpSupply)).toUint128();
            }
            pool.lastRewardTime = uint64(block.timestamp);
            poolInfo[pid] = pool;
            emit LogUpdatePool(pid, pool.lastRewardTime, lpSupply, pool.accBooPerShare);
        }
    }

    function updatePool(uint pid) external returns (PoolInfo memory pool) {
        return _updatePool(pid);
    }

    function deposit(uint pid, uint amount, address to) external nonReentrant validatePid(pid) {
        _deposit(pid, amount, to);
    }

    function deposit(uint pid, uint amount) external nonReentrant validatePid(pid) {
        _deposit(pid, amount, msg.sender);
    }


    /// @notice Deposit LP tokens to MCV2 for BOO allocation.
    /// @param pid The index of the pool. See `poolInfo`.
    /// @param amount LP token amount to deposit.
    /// @param to The receiver of `amount` deposit benefit.
    function _deposit(uint pid, uint amount, address to) internal {
        _updatePool(pid);
        PoolInfo storage pool = poolInfo[pid];
        UserInfo storage user = userInfo[pid][to];

        // Effects
        uint256 _pendingBoo = (user.amount * pool.accBooPerShare / ACC_BOO_PRECISION) - user.rewardDebt;

        user.amount += amount;
        user.rewardDebt = user.amount * pool.accBooPerShare / ACC_BOO_PRECISION;

        // Interactions
        if (_pendingBoo != 0) {
            BOO.safeTransfer(to, _pendingBoo);
        }

        IRewarder _rewarder = rewarder[pid];
        if (address(_rewarder) != address(0)) {
            _rewarder.onReward(pid, to, to, _pendingBoo, user.amount);
        }

        if(amount > 0) {
            lpToken[pid].safeTransferFrom(msg.sender, address(this), amount);
            lpSupplies[pid] += amount;
        }

        emit Deposit(msg.sender, pid, amount, to);
        emit Harvest(msg.sender, pid, _pendingBoo);
    }

    function withdraw(uint pid, uint amount, address to) external nonReentrant validatePid(pid) {
        _withdraw(pid, amount, to);
    }

    function withdraw(uint pid, uint amount) external nonReentrant validatePid(pid) {
        _withdraw(pid, amount, msg.sender);
    }

    /// @notice Withdraw LP tokens from MCV2 and harvest proceeds for transaction sender to `to`.
    /// @param pid The index of the pool. See `poolInfo`.
    /// @param amount LP token amount to withdraw.
    /// @param to Receiver of the LP tokens and BOO rewards.
    function _withdraw(uint pid, uint amount, address to) internal {
        _updatePool(pid);
        PoolInfo storage pool = poolInfo[pid];
        UserInfo storage user = userInfo[pid][msg.sender];

        require(user.amount >= amount, "withdraw: not good");

        // Effects
        uint256 _pendingBoo = (user.amount * pool.accBooPerShare / ACC_BOO_PRECISION) - user.rewardDebt;

        user.amount -= amount;
        user.rewardDebt = user.amount * pool.accBooPerShare / ACC_BOO_PRECISION;

        // Interactions
        if (_pendingBoo != 0) {
            BOO.safeTransfer(to, _pendingBoo);
        }

        IRewarder _rewarder = rewarder[pid];
        if (address(_rewarder) != address(0)) {
            _rewarder.onReward(pid, msg.sender, to, _pendingBoo, user.amount);
        }

        if(amount > 0) {
            lpToken[pid].safeTransfer(to, amount);
            lpSupplies[pid] -= amount;
        }

        emit Withdraw(msg.sender, pid, amount, to);
        emit Harvest(msg.sender, pid, _pendingBoo);
    }

    /// @notice Batch harvest all rewards from all staked pools
    /// @dev This function has an unbounded gas cost. Take care not to call it from other smart contracts if you don't know what you're doing.
    function harvestAll() external nonReentrant {
        uint256 length = poolInfoAmount;
        uint calc;
        uint pending;
        UserInfo storage user;
        PoolInfo memory pool;
        uint totalPending;
        for (uint256 pid = 0; pid < length; ++pid) {
            user = userInfo[pid][msg.sender];
            if (user.amount > 0) {
                pool = _updatePool(pid);

                calc = user.amount * pool.accBooPerShare / ACC_BOO_PRECISION;
                pending = calc - user.rewardDebt;
                user.rewardDebt = calc;

                if(pending > 0) {
                    totalPending+=pending;
                }

                IRewarder _rewarder = rewarder[pid];
                if (address(_rewarder) != address(0)) {
                    _rewarder.onReward(pid, msg.sender, msg.sender, pending, user.amount);
                }
            }
        }
        if (totalPending > 0) {
            BOO.safeTransfer(msg.sender, totalPending);
        }
    }

    /// @notice Batch harvest rewards from specified staked pools
    /// @param pids[] The array of pids of the pools you wish to harvest. See `poolInfo`.
    function harvestMultiple(uint[] calldata pids) external nonReentrant {
        uint256 length = pids.length;
        uint calc;
        uint pending;
        UserInfo storage user;
        PoolInfo memory pool;
        uint totalPending;
        uint pid;
        for (uint256 i = 0; i < length; ++i) {
            pid = pids[i];
            user = userInfo[pid][msg.sender];
            if (user.amount > 0) {
                pool = _updatePool(pid);

                calc = user.amount * pool.accBooPerShare / ACC_BOO_PRECISION;
                pending = calc - user.rewardDebt;
                user.rewardDebt = calc;

                if(pending > 0) {
                    totalPending+=pending;
                }

                IRewarder _rewarder = rewarder[pid];
                if (address(_rewarder) != address(0)) {
                    _rewarder.onReward(pid, msg.sender, msg.sender, pending, user.amount);
                }
            }

        }
        if (totalPending > 0) {
            BOO.safeTransfer(msg.sender, totalPending);
        }
    }

    /// @notice Harvests BOO from `MASTER_CHEF` MCV1 and pool `MASTER_PID` to this MCV2 contract.
    function harvestFromMasterChef() public {
        lastV1HarvestTimestamp = block.timestamp;
        MASTER_CHEF.deposit(MASTER_PID, 0);
    }

    /// @notice calls harvestFromMasterChef() if its been more than `V1_HARVEST_QUERY_TIME` since last v1 harvest
    function queryHarvestFromMasterChef() public {
        if(block.timestamp - lastV1HarvestTimestamp > V1_HARVEST_QUERY_TIME)
            harvestFromMasterChef();
    }

    /// @notice Withdraw without caring about rewards. EMERGENCY ONLY.
    /// @param pid The index of the pool. See `poolInfo`.
    /// @param to Receiver of the LP tokens.
    function _emergencyWithdraw(uint pid, address to) internal validatePid(pid) {
        UserInfo storage user = userInfo[pid][msg.sender];
        uint amount = user.amount;
        user.amount = 0;
        user.rewardDebt = 0;

        IRewarder _rewarder = rewarder[pid];
        if (address(_rewarder) != address(0)) {
            _rewarder.onReward(pid, msg.sender, to, 0, 0);
        }

        // Note: transfer can fail or succeed if `amount` is zero.
        lpToken[pid].safeTransfer(to, amount);
        lpSupplies[pid] -= amount;
        emit EmergencyWithdraw(msg.sender, pid, amount, to);
    }

    function emergencyWithdraw(uint pid, address to) external nonReentrant {
        _emergencyWithdraw(pid, to);
    }

    function emergencyWithdraw(uint pid) external nonReentrant {
        _emergencyWithdraw(pid, msg.sender);
    }


    // ADMIN FUNCTIONS

    /// @notice Add a new LP to the pool. Can only be called by the owner.
    /// @param allocPoint AP of the new pool.
    /// @param _lpToken Address of the LP ERC-20 token.
    /// @param _rewarder Addresses of the rewarder delegate(s).
    function add(uint64 allocPoint, IERC20 _lpToken, IRewarder _rewarder, bool update) external onlyAuth {
        checkForDuplicate(_lpToken);
        
        if (update) {
            massUpdateAllPools();
        }

        uint pid = poolInfoAmount;
        uint64 lastRewardTime = uint64(block.timestamp);
        totalAllocPoint = totalAllocPoint + allocPoint;
        lpToken[pid] = _lpToken;
        isLpToken[_lpToken] = true;
        rewarder[pid] = _rewarder;

        PoolInfo storage poolinfo = poolInfo[pid];
        poolinfo.allocPoint = allocPoint;
        poolinfo.lastRewardTime = lastRewardTime;
        poolinfo.accBooPerShare = 0;

        poolInfoAmount = poolInfoAmount + 1;

        emit LogPoolAddition(pid, allocPoint, _lpToken, _rewarder, update);
    }

    /// @notice Update the given pool's BOO allocation point and `IRewarder` contract. Can only be called by the owner.
    /// @param _pid The index of the pool. See `poolInfo`.
    /// @param _allocPoint New AP of the pool.
    /// @param _rewarder Addresses of the rewarder delegates.
    /// @param overwrite True if _rewarders should be `set`. Otherwise `_rewarders` is ignored.
    function set(uint _pid, uint64 _allocPoint, IRewarder _rewarder, bool overwrite, bool update) external onlyAuth {
        _set(_pid, _allocPoint, _rewarder, overwrite, update);
    }

    /// @notice Batch update the given pool's BOO allocation point and `IRewarder` contract. Can only be called by the owner.
    /// @param _pid The index of the pool. See `poolInfo`.
    /// @param _allocPoint New AP of the pool.
    /// @param _rewarders Addresses of the rewarder delegates.
    /// @param overwrite True if _rewarders should be `set`. Otherwise `_rewarders` is ignored.
    function setBatch(uint[] calldata _pid, uint64[] calldata _allocPoint, IRewarder[] calldata _rewarders, bool[] calldata overwrite, bool update) external onlyAuth {
        require(_pid.length == _allocPoint.length && _allocPoint.length == _rewarders.length && _rewarders.length == overwrite.length, "MCV2: all arrays need to be the same length");

        if(update)
            massUpdateAllPools();

        uint len = _pid.length;
        for(uint i = 0; i < len; i++)
            _set(_pid[i], _allocPoint[i], _rewarders[i], overwrite[i], false);
    }

    function setBatchSlim(uint[] calldata _pid, uint64[] calldata _allocPoint, bool update) external onlyAuth {
        if(update)
            massUpdateAllPools();

        uint len = _pid.length;
        for(uint i = 0; i < len; i++)
            _set(_pid[i], _allocPoint[i], IRewarder(address(0)), false, false);
    }



    function _set(uint _pid, uint64 _allocPoint, IRewarder _rewarder, bool overwrite, bool update) internal validatePid(_pid) {
        if (update) {
            massUpdateAllPools();
        }

        totalAllocPoint = totalAllocPoint - poolInfo[_pid].allocPoint + _allocPoint;
        poolInfo[_pid].allocPoint = _allocPoint;
        if (overwrite) rewarder[_pid] = _rewarder;

        emit LogSetPool(_pid, _allocPoint, overwrite ? _rewarder : rewarder[_pid], overwrite, update);
    }

    function setV1HarvestQueryTime(uint256 newTime, bool inDays) external onlyAuth {
        V1_HARVEST_QUERY_TIME = newTime * (inDays ? 1 days : 1);
    }


}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)

pragma solidity ^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 `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, 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 `from` to `to` 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 from,
        address to,
        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);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../../../utils/Address.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 IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    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'
        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) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _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
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/math/SafeCast.sol)

pragma solidity ^0.8.0;

/**
 * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
 * checks.
 *
 * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
 * easily result in undesired exploitation or bugs, since developers usually
 * assume that overflows raise errors. `SafeCast` restores this intuition by
 * reverting the transaction when such 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.
 *
 * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing
 * all math on `uint256` and `int256` and then downcasting.
 */
library SafeCast {
    /**
     * @dev Returns the downcasted uint224 from uint256, reverting on
     * overflow (when the input is greater than largest uint224).
     *
     * Counterpart to Solidity's `uint224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     */
    function toUint224(uint256 value) internal pure returns (uint224) {
        require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
        return uint224(value);
    }

    /**
     * @dev Returns the downcasted uint128 from uint256, reverting on
     * overflow (when the input is greater than largest uint128).
     *
     * Counterpart to Solidity's `uint128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     */
    function toUint128(uint256 value) internal pure returns (uint128) {
        require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
        return uint128(value);
    }

    /**
     * @dev Returns the downcasted uint96 from uint256, reverting on
     * overflow (when the input is greater than largest uint96).
     *
     * Counterpart to Solidity's `uint96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     */
    function toUint96(uint256 value) internal pure returns (uint96) {
        require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
        return uint96(value);
    }

    /**
     * @dev Returns the downcasted uint64 from uint256, reverting on
     * overflow (when the input is greater than largest uint64).
     *
     * Counterpart to Solidity's `uint64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     */
    function toUint64(uint256 value) internal pure returns (uint64) {
        require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
        return uint64(value);
    }

    /**
     * @dev Returns the downcasted uint32 from uint256, reverting on
     * overflow (when the input is greater than largest uint32).
     *
     * Counterpart to Solidity's `uint32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     */
    function toUint32(uint256 value) internal pure returns (uint32) {
        require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
        return uint32(value);
    }

    /**
     * @dev Returns the downcasted uint16 from uint256, reverting on
     * overflow (when the input is greater than largest uint16).
     *
     * Counterpart to Solidity's `uint16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     */
    function toUint16(uint256 value) internal pure returns (uint16) {
        require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
        return uint16(value);
    }

    /**
     * @dev Returns the downcasted uint8 from uint256, reverting on
     * overflow (when the input is greater than largest uint8).
     *
     * Counterpart to Solidity's `uint8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits.
     */
    function toUint8(uint256 value) internal pure returns (uint8) {
        require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
        return uint8(value);
    }

    /**
     * @dev Converts a signed int256 into an unsigned uint256.
     *
     * Requirements:
     *
     * - input must be greater than or equal to 0.
     */
    function toUint256(int256 value) internal pure returns (uint256) {
        require(value >= 0, "SafeCast: value must be positive");
        return uint256(value);
    }

    /**
     * @dev Returns the downcasted int128 from int256, reverting on
     * overflow (when the input is less than smallest int128 or
     * greater than largest int128).
     *
     * Counterpart to Solidity's `int128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     *
     * _Available since v3.1._
     */
    function toInt128(int256 value) internal pure returns (int128) {
        require(value >= type(int128).min && value <= type(int128).max, "SafeCast: value doesn't fit in 128 bits");
        return int128(value);
    }

    /**
     * @dev Returns the downcasted int64 from int256, reverting on
     * overflow (when the input is less than smallest int64 or
     * greater than largest int64).
     *
     * Counterpart to Solidity's `int64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     *
     * _Available since v3.1._
     */
    function toInt64(int256 value) internal pure returns (int64) {
        require(value >= type(int64).min && value <= type(int64).max, "SafeCast: value doesn't fit in 64 bits");
        return int64(value);
    }

    /**
     * @dev Returns the downcasted int32 from int256, reverting on
     * overflow (when the input is less than smallest int32 or
     * greater than largest int32).
     *
     * Counterpart to Solidity's `int32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     *
     * _Available since v3.1._
     */
    function toInt32(int256 value) internal pure returns (int32) {
        require(value >= type(int32).min && value <= type(int32).max, "SafeCast: value doesn't fit in 32 bits");
        return int32(value);
    }

    /**
     * @dev Returns the downcasted int16 from int256, reverting on
     * overflow (when the input is less than smallest int16 or
     * greater than largest int16).
     *
     * Counterpart to Solidity's `int16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     *
     * _Available since v3.1._
     */
    function toInt16(int256 value) internal pure returns (int16) {
        require(value >= type(int16).min && value <= type(int16).max, "SafeCast: value doesn't fit in 16 bits");
        return int16(value);
    }

    /**
     * @dev Returns the downcasted int8 from int256, reverting on
     * overflow (when the input is less than smallest int8 or
     * greater than largest int8).
     *
     * Counterpart to Solidity's `int8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits.
     *
     * _Available since v3.1._
     */
    function toInt8(int256 value) internal pure returns (int8) {
        require(value >= type(int8).min && value <= type(int8).max, "SafeCast: value doesn't fit in 8 bits");
        return int8(value);
    }

    /**
     * @dev Converts an unsigned uint256 into a signed int256.
     *
     * Requirements:
     *
     * - input must be less than or equal to maxInt256.
     */
    function toInt256(uint256 value) internal pure returns (int256) {
        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
        require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
        return int256(value);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';

interface IRewarder {
    function onReward(uint256 pid, address user, address recipient, uint256 Booamount, uint256 newLpAmount) external;
    function pendingTokens(uint256 pid, address user, uint256 rewardAmount) external view returns (IERC20[] memory, uint256[] memory);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';

interface IMasterChef {
    struct UserInfo {
        uint256 amount;     // How many LP tokens the user has provided.
        uint256 rewardDebt; // Reward debt. See explanation below.
    }

    struct PoolInfo {
        IERC20 lpToken;           // Address of LP token contract.
        uint256 allocPoint;       // How many allocation points assigned to this pool. BOO to distribute per second.
        uint256 lastRewardBlock;  // Last block number that SUSHI distribution occurs.
        uint256 accBooPerShare; // Accumulated BOO per share, times 1e12. See below.
    }

    function poolInfo(uint256 pid) external view returns (IMasterChef.PoolInfo memory);
    function totalAllocPoint() external view returns (uint256);
    function booPerSecond() external view returns (uint256);
    function deposit(uint256 _pid, uint256 _amount) external;
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8;

interface IOwnable {
    function transferOwnership(address newOwner) external;
}

abstract contract SpookyAuth {
    // set of addresses that can perform certain functions
    mapping(address => bool) public isAuth;
    address[] public authorized;
    address public admin;

    modifier onlyAuth() {
        require(isAuth[msg.sender] || msg.sender == admin, "SpookySwap: FORBIDDEN (auth)");
        _;
    }

    modifier onlyOwner() { //Ownable compatibility
        require(isAuth[msg.sender] || msg.sender == admin, "SpookySwap: FORBIDDEN (auth)");
        _;
    }

    modifier onlyAdmin() {
        require(msg.sender == admin, "SpookySwap: FORBIDDEN (admin)");
        _;
    }

    event AddAuth(address indexed by, address indexed to);
    event RevokeAuth(address indexed by, address indexed to);
    event SetAdmin(address indexed by, address indexed to);

    constructor() {
        admin = msg.sender;
        emit SetAdmin(address(this), msg.sender);
        isAuth[msg.sender] = true;
        authorized.push(msg.sender);
        emit AddAuth(address(this), msg.sender);
    }

    function setAdmin(address newAdmin) external onlyAdmin {
        admin = newAdmin;
        emit SetAdmin(msg.sender, newAdmin);
    }

    function addAuth(address _auth) external onlyAuth {
        isAuth[_auth] = true;
        authorized.push(_auth);
        emit AddAuth(msg.sender, _auth);
    }

    function revokeAuth(address _auth) external onlyAuth {
        require(_auth != admin);
        isAuth[_auth] = false;
        emit RevokeAuth(msg.sender, _auth);
    }
}

// SPDX-License-Identifier: GPL-3.0-or-later

pragma solidity >=0.8.0;

/// @notice Helper utility that enables calling multiple local methods in a single call.
/// @author Modified from Uniswap (https://github.com/Uniswap/v3-periphery/blob/main/contracts/base/Multicall.sol)
/// License-Identifier: GPL-2.0-or-later
abstract contract Multicall {
    function multicall(bytes[] calldata data) public payable returns (bytes[] memory results) {
        results = new bytes[](data.length);

        for (uint256 i; i < data.length;) {
            (bool success, bytes memory result) = address(this).delegatecall(data[i]);

            if (!success) {
                // Next 5 lines from https://ethereum.stackexchange.com/a/83577
                if (result.length < 68) revert();
                assembly {
                    result := add(result, 0x04)
                }
                revert(abi.decode(result, (string)));
            }

            results[i] = result;

            // cannot realistically overflow on human timescales
        unchecked {
            ++i;
        }
        }
    }
}

// SPDX-License-Identifier: GPL-3.0-or-later

pragma solidity >=0.8.0;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol";

interface IERC20PermitAllowed {
    function permit(
        address holder,
        address spender,
        uint256 nonce,
        uint256 expiry,
        bool allowed,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;
}

abstract contract SelfPermit {
    function selfPermit(
        address token,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public payable {
        IERC20Permit(token).permit(msg.sender, address(this), value, deadline, v, r, s);
    }

    function selfPermitIfNecessary(
        address token,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external payable {
        if (IERC20(token).allowance(msg.sender, address(this)) < value) selfPermit(token, value, deadline, v, r, s);
    }

    function selfPermitAllowed(

        address token,
        uint256 nonce,
        uint256 expiry,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public payable {
        IERC20PermitAllowed(token).permit(msg.sender, address(this), nonce, expiry, true, v, r, s);
    }

    function selfPermitAllowedIfNecessary(
        address token,
        uint256 nonce,
        uint256 expiry,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external payable {
        if (IERC20(token).allowance(msg.sender, address(this)) < type(uint256).max)
            selfPermitAllowed(token, nonce, expiry, v, r, s);
    }

    function supportsPermits(address token) external view returns (bytes32 domainSeparator) {
        try IERC20Permit(token).DOMAIN_SEPARATOR() returns (bytes32 separator) {
            return separator;
        } catch {
            return bytes32(0);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @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
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 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");

        (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");

        (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");

        (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");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal 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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

{
  "optimizer": {
    "enabled": true,
    "runs": 9999
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IMasterChef","name":"_MASTER_CHEF","type":"address"},{"internalType":"contract IERC20","name":"_boo","type":"address"},{"internalType":"uint256","name":"_MASTER_PID","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"by","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"AddAuth","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Harvest","type":"event"},{"anonymous":false,"inputs":[],"name":"LogInit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"allocPoint","type":"uint256"},{"indexed":true,"internalType":"contract IERC20","name":"lpToken","type":"address"},{"indexed":false,"internalType":"contract IRewarder","name":"rewarder","type":"address"},{"indexed":false,"internalType":"bool","name":"update","type":"bool"}],"name":"LogPoolAddition","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"allocPoint","type":"uint256"},{"indexed":false,"internalType":"contract IRewarder","name":"rewarder","type":"address"},{"indexed":false,"internalType":"bool","name":"overwrite","type":"bool"},{"indexed":false,"internalType":"bool","name":"update","type":"bool"}],"name":"LogSetPool","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"lastRewardTime","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"lpSupply","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"accBooPerShare","type":"uint256"}],"name":"LogUpdatePool","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"by","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"RevokeAuth","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"by","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"SetAdmin","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"BOO","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MASTER_CHEF","outputs":[{"internalType":"contract IMasterChef","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MASTER_PID","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"V1_HARVEST_QUERY_TIME","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint64","name":"allocPoint","type":"uint64"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"},{"internalType":"contract IRewarder","name":"_rewarder","type":"address"},{"internalType":"bool","name":"update","type":"bool"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_auth","type":"address"}],"name":"addAuth","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"admin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"authorized","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"booPerSecond","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"pid","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"pid","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"pid","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"pid","type":"uint256"}],"name":"getFarmData","outputs":[{"components":[{"internalType":"uint128","name":"accBooPerShare","type":"uint128"},{"internalType":"uint64","name":"lastRewardTime","type":"uint64"},{"internalType":"uint64","name":"allocPoint","type":"uint64"}],"internalType":"struct MasterChefV2.PoolInfo","name":"","type":"tuple"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"contract IRewarder","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"harvestAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"harvestFromMasterChef","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"pids","type":"uint256[]"}],"name":"harvestMultiple","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"dummyToken","type":"address"}],"name":"init","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isAuth","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"name":"isLpToken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastV1HarvestTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"lpSupplies","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"lpToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"massUpdateAllPools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"pids","type":"uint256[]"}],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"multicall","outputs":[{"internalType":"bytes[]","name":"results","type":"bytes[]"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingBOO","outputs":[{"internalType":"uint256","name":"pending","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"uint128","name":"accBooPerShare","type":"uint128"},{"internalType":"uint64","name":"lastRewardTime","type":"uint64"},{"internalType":"uint64","name":"allocPoint","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolInfoAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"pools","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"queryHarvestFromMasterChef","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_auth","type":"address"}],"name":"revokeAuth","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"rewarder","outputs":[{"internalType":"contract IRewarder","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"selfPermit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"selfPermitAllowed","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"selfPermitAllowedIfNecessary","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"selfPermitIfNecessary","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint64","name":"_allocPoint","type":"uint64"},{"internalType":"contract IRewarder","name":"_rewarder","type":"address"},{"internalType":"bool","name":"overwrite","type":"bool"},{"internalType":"bool","name":"update","type":"bool"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newAdmin","type":"address"}],"name":"setAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_pid","type":"uint256[]"},{"internalType":"uint64[]","name":"_allocPoint","type":"uint64[]"},{"internalType":"contract IRewarder[]","name":"_rewarders","type":"address[]"},{"internalType":"bool[]","name":"overwrite","type":"bool[]"},{"internalType":"bool","name":"update","type":"bool"}],"name":"setBatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_pid","type":"uint256[]"},{"internalType":"uint64[]","name":"_allocPoint","type":"uint64[]"},{"internalType":"bool","name":"update","type":"bool"}],"name":"setBatchSlim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newTime","type":"uint256"},{"internalType":"bool","name":"inDays","type":"bool"}],"name":"setV1HarvestQueryTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"supportsPermits","outputs":[{"internalType":"bytes32","name":"domainSeparator","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"pid","type":"uint256"}],"name":"updatePool","outputs":[{"components":[{"internalType":"uint128","name":"accBooPerShare","type":"uint128"},{"internalType":"uint64","name":"lastRewardTime","type":"uint64"},{"internalType":"uint64","name":"allocPoint","type":"uint64"}],"internalType":"struct MasterChefV2.PoolInfo","name":"pool","type":"tuple"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"pid","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"pid","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000002b2929e785374c651a81a63878ab22742656dcdd000000000000000000000000841fad6eae12c286d1fd18d1d525dffa75c7effe0000000000000000000000000000000000000000000000000000000000000053

-----Decoded View---------------
Arg [0] : _MASTER_CHEF (address): 0x2b2929e785374c651a81a63878ab22742656dcdd
Arg [1] : _boo (address): 0x841fad6eae12c286d1fd18d1d525dffa75c7effe
Arg [2] : _MASTER_PID (uint256): 83

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 0000000000000000000000002b2929e785374c651a81a63878ab22742656dcdd
Arg [1] : 000000000000000000000000841fad6eae12c286d1fd18d1d525dffa75c7effe
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000053