Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import {Ownable} from '@openzeppelin/contracts/access/Ownable.sol';
import {Pausable} from '@openzeppelin/contracts/security/Pausable.sol';
import {ReentrancyGuard} from '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import {IERC20, SafeERC20} from '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';

import {IUniswapV2Router02} from './IUniswapV2Router02.sol';
import {FeeSharingSystem} from './FeeSharingSystem.sol';

/**
 * @title X2Y2Compounder
 * @notice It sells WETH to X2Y2 using Uniswap V2.
 * @dev Prime shares represent the number of shares in the FeeSharingSystem. When not specified, shares represent secondary shares in this contract.
 */
contract X2Y2Compounder is Ownable, Pausable, ReentrancyGuard {
    using SafeERC20 for IERC20;

    // Maximum buffer between 2 harvests (in blocks)
    uint256 public constant MAXIMUM_HARVEST_BUFFER_BLOCKS = 6500;

    // FeeSharingSystem (handles the distribution of WETH for X2Y2 stakers)
    FeeSharingSystem public immutable feeSharingSystem;

    // Uniswap V2
    IUniswapV2Router02 public immutable uniswapRouter;

    // Minimum deposit in X2Y2 (it is derived from the FeeSharingSystem)
    uint256 public immutable MINIMUM_DEPOSIT_X2Y2;

    // Token Address
    IERC20 public immutable x2y2Token;

    // Reward token (WETH)
    IERC20 public immutable rewardToken;

    // Whether harvest and WETH selling is triggered automatically at user action
    bool public canHarvest;

    // Buffer between two harvests (in blocks)
    uint256 public harvestBufferBlocks;

    // Last user action block
    uint256 public lastHarvestBlock;

    // Maximum price of X2Y2 (in WETH) multiplied 1e18 (e.g., 0.0004 ETH --> 4e14)
    uint256 public maxPriceX2Y2InWETH;

    // Threshold amount (in rewardToken)
    uint256 public thresholdAmount;

    // Total number of shares outstanding
    uint256 public totalShares;

    // Keeps track of number of user shares
    mapping(address => uint256) public userInfo;

    event ConversionToX2Y2(uint256 amountSold, uint256 amountReceived);
    event Deposit(address indexed user, uint256 amount);
    event FailedConversion();
    event HarvestStart();
    event HarvestStop();
    event NewHarvestBufferBlocks(uint256 harvestBufferBlocks);
    event NewMaximumPriceX2Y2InWETH(uint256 value);
    event NewThresholdAmount(uint256 thresholdAmount);
    event Withdraw(address indexed user, uint256 amount);

    /**
     * @notice Constructor
     * @param _feeSharingSystem address of the fee sharing system contract
     * @param _uniswapRouter address of the Uniswap v3 router
     */
    constructor(FeeSharingSystem _feeSharingSystem, IUniswapV2Router02 _uniswapRouter) {
        feeSharingSystem = FeeSharingSystem(_feeSharingSystem);

        x2y2Token = IERC20(_feeSharingSystem.x2y2Token());
        rewardToken = IERC20(_feeSharingSystem.rewardToken());

        uniswapRouter = _uniswapRouter;

        x2y2Token.approve(address(_feeSharingSystem), type(uint256).max);
        rewardToken.approve(address(_uniswapRouter), type(uint256).max);

        MINIMUM_DEPOSIT_X2Y2 = FeeSharingSystem(_feeSharingSystem).PRECISION_FACTOR();
    }

    /**
     * @notice Deposit X2Y2 tokens
     * @param amount amount to deposit (in X2Y2)
     * @dev There is a limit of 1 X2Y2 per deposit to prevent potential manipulation of the shares
     */
    function deposit(uint256 amount) external nonReentrant whenNotPaused {
        require(amount >= MINIMUM_DEPOSIT_X2Y2, 'Deposit: Amount must be >= 1 X2Y2');

        if (
            block.number > (lastHarvestBlock + harvestBufferBlocks) &&
            canHarvest &&
            totalShares != 0
        ) {
            _harvestAndSellAndCompound();
        }

        // Transfer X2Y2 tokens to this address
        x2y2Token.safeTransferFrom(msg.sender, address(this), amount);

        // Fetch the total number of X2Y2 staked by this contract
        uint256 totalAmountStaked = feeSharingSystem.calculateSharesValueInX2Y2(address(this));

        uint256 currentShares = totalShares == 0
            ? amount
            : (amount * totalShares) / totalAmountStaked;
        require(currentShares != 0, 'Deposit: Fail');

        // Adjust number of shares for user/total
        userInfo[msg.sender] += currentShares;
        totalShares += currentShares;

        // Deposit to FeeSharingSystem contract
        feeSharingSystem.deposit(amount, false);

        emit Deposit(msg.sender, amount);
    }

    /**
     * @notice Redeem shares for X2Y2 tokens
     * @param shares number of shares to redeem
     */
    function withdraw(uint256 shares) external nonReentrant {
        require(
            (shares > 0) && (shares <= userInfo[msg.sender]),
            'Withdraw: Shares equal to 0 or larger than user shares'
        );

        _withdraw(shares);
    }

    /**
     * @notice Withdraw all shares of sender
     */
    function withdrawAll() external nonReentrant {
        require(userInfo[msg.sender] > 0, 'Withdraw: Shares equal to 0');

        _withdraw(userInfo[msg.sender]);
    }

    /**
     * @notice Harvest pending WETH, sell them to X2Y2, and deposit X2Y2 (if possible)
     * @dev Only callable by owner.
     */
    function harvestAndSellAndCompound() external nonReentrant onlyOwner {
        require(totalShares != 0, 'Harvest: No share');
        require(block.number != lastHarvestBlock, 'Harvest: Already done');

        _harvestAndSellAndCompound();
    }

    /**
     * @notice Adjust allowance if necessary
     * @dev Only callable by owner.
     */
    function checkAndAdjustX2Y2TokenAllowanceIfRequired() external onlyOwner {
        x2y2Token.approve(address(feeSharingSystem), type(uint256).max);
    }

    /**
     * @notice Adjust allowance if necessary
     * @dev Only callable by owner.
     */
    function checkAndAdjustRewardTokenAllowanceIfRequired() external onlyOwner {
        rewardToken.approve(address(uniswapRouter), type(uint256).max);
    }

    /**
     * @notice Update harvest buffer block
     * @param _newHarvestBufferBlocks buffer in blocks between two harvest operations
     * @dev Only callable by owner.
     */
    function updateHarvestBufferBlocks(uint256 _newHarvestBufferBlocks) external onlyOwner {
        require(
            _newHarvestBufferBlocks <= MAXIMUM_HARVEST_BUFFER_BLOCKS,
            'Owner: Must be below MAXIMUM_HARVEST_BUFFER_BLOCKS'
        );
        harvestBufferBlocks = _newHarvestBufferBlocks;

        emit NewHarvestBufferBlocks(_newHarvestBufferBlocks);
    }

    /**
     * @notice Start automatic harvest/selling transactions
     * @dev Only callable by owner
     */
    function startHarvest() external onlyOwner {
        canHarvest = true;

        emit HarvestStart();
    }

    /**
     * @notice Stop automatic harvest transactions
     * @dev Only callable by owner
     */
    function stopHarvest() external onlyOwner {
        canHarvest = false;

        emit HarvestStop();
    }

    /**
     * @notice Update maximum price of X2Y2 in WETH
     * @param _newMaxPriceX2Y2InWETH new maximum price of X2Y2 in WETH times 1e18
     * @dev Only callable by owner
     */
    function updateMaxPriceOfX2Y2InWETH(uint256 _newMaxPriceX2Y2InWETH) external onlyOwner {
        maxPriceX2Y2InWETH = _newMaxPriceX2Y2InWETH;

        emit NewMaximumPriceX2Y2InWETH(_newMaxPriceX2Y2InWETH);
    }

    /**
     * @notice Adjust threshold amount for periodic Uniswap v3 WETH --> X2Y2 conversion
     * @param _newThresholdAmount new threshold amount (in WETH)
     * @dev Only callable by owner
     */
    function updateThresholdAmount(uint256 _newThresholdAmount) external onlyOwner {
        thresholdAmount = _newThresholdAmount;

        emit NewThresholdAmount(_newThresholdAmount);
    }

    /**
     * @notice Pause
     * @dev Only callable by owner
     */
    function pause() external onlyOwner whenNotPaused {
        _pause();
    }

    /**
     * @notice Unpause
     * @dev Only callable by owner
     */
    function unpause() external onlyOwner whenPaused {
        _unpause();
    }

    /**
     * @notice Calculate price of one share (in X2Y2 token)
     * Share price is expressed times 1e18
     */
    function calculateSharePriceInX2Y2() external view returns (uint256) {
        uint256 totalAmountStakedWithAggregator = feeSharingSystem.calculateSharesValueInX2Y2(
            address(this)
        );

        return
            totalShares == 0
                ? MINIMUM_DEPOSIT_X2Y2
                : (totalAmountStakedWithAggregator * MINIMUM_DEPOSIT_X2Y2) / (totalShares);
    }

    /**
     * @notice Calculate price of one share (in prime share)
     * Share price is expressed times 1e18
     */
    function calculateSharePriceInPrimeShare() external view returns (uint256) {
        (uint256 totalNumberPrimeShares, , ) = feeSharingSystem.userInfo(address(this));

        return
            totalShares == 0
                ? MINIMUM_DEPOSIT_X2Y2
                : (totalNumberPrimeShares * MINIMUM_DEPOSIT_X2Y2) / totalShares;
    }

    /**
     * @notice Calculate shares value of a user (in X2Y2)
     * @param user address of the user
     */
    function calculateSharesValueInX2Y2(address user) external view returns (uint256) {
        uint256 totalAmountStakedWithAggregator = feeSharingSystem.calculateSharesValueInX2Y2(
            address(this)
        );

        return
            totalShares == 0 ? 0 : (totalAmountStakedWithAggregator * userInfo[user]) / totalShares;
    }

    /**
     * @notice Harvest pending WETH, sell them to X2Y2, and deposit X2Y2 (if possible)
     */
    function _harvestAndSellAndCompound() internal {
        // Try/catch to prevent revertions if nothing to harvest
        try feeSharingSystem.harvest() {} catch {}

        uint256 amountToSell = rewardToken.balanceOf(address(this));

        if (amountToSell >= thresholdAmount) {
            bool isExecuted = _sellRewardTokenToX2Y2(amountToSell);

            if (isExecuted) {
                uint256 adjustedAmount = x2y2Token.balanceOf(address(this));

                if (adjustedAmount >= MINIMUM_DEPOSIT_X2Y2) {
                    feeSharingSystem.deposit(adjustedAmount, false);
                }
            }
        }

        // Adjust last harvest block
        lastHarvestBlock = block.number;
    }

    /**
     * @notice Sell WETH to X2Y2
     * @param _amount amount of rewardToken to convert (WETH)
     * @return whether the transaction went through
     */
    function _sellRewardTokenToX2Y2(uint256 _amount) internal returns (bool) {
        uint256 minAmountOut = 0;
        if (maxPriceX2Y2InWETH > 0) {
            minAmountOut = (_amount * 1e18) / maxPriceX2Y2InWETH;
        }

        address[] memory path = new address[](2);
        path[0] = address(rewardToken);
        path[1] = address(x2y2Token);

        try
            uniswapRouter.swapExactTokensForTokens(
                _amount, // amountIn
                minAmountOut, // amountOutMin
                path, // path
                address(this), // to
                block.timestamp // deadline
            )
        returns (uint256[] memory amounts) {
            emit ConversionToX2Y2(amounts[0], amounts[1]);
            return true;
        } catch {
            emit FailedConversion();
            return false;
        }

        return false;
    }

    /**
     * @notice Withdraw shares
     * @param _shares number of shares to redeem
     * @dev The difference between the two snapshots of X2Y2 balances is used to know how many tokens to transfer to user.
     */
    function _withdraw(uint256 _shares) internal {
        if (block.number > (lastHarvestBlock + harvestBufferBlocks) && canHarvest) {
            _harvestAndSellAndCompound();
        }

        // Take snapshot of current X2Y2 balance
        uint256 previousBalanceX2Y2 = x2y2Token.balanceOf(address(this));

        // Fetch total number of prime shares
        (uint256 totalNumberPrimeShares, , ) = feeSharingSystem.userInfo(address(this));

        // Calculate number of prime shares to redeem based on existing shares (from this contract)
        uint256 currentNumberPrimeShares = (totalNumberPrimeShares * _shares) / totalShares;

        // Adjust number of shares for user/total
        userInfo[msg.sender] -= _shares;
        totalShares -= _shares;

        // Withdraw amount equivalent in prime shares
        feeSharingSystem.withdraw(currentNumberPrimeShares, false);

        // Calculate the difference between the current balance of X2Y2 with the previous snapshot
        uint256 amountToTransfer = x2y2Token.balanceOf(address(this)) - previousBalanceX2Y2;

        // Transfer the x2y2 amount back to user
        x2y2Token.safeTransfer(msg.sender, amountToTransfer);

        emit Withdraw(msg.sender, amountToTransfer);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

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

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        require(!paused(), "Pausable: paused");
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        require(paused(), "Pausable: not paused");
        _;
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

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

pragma solidity >=0.6.2;

import './IUniswapV2Router01.sol';

interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountETH);

    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;

    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable;

    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import {AccessControl} from '@openzeppelin/contracts/access/AccessControl.sol';
import {IERC20, SafeERC20} from '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
import {ReentrancyGuard} from '@openzeppelin/contracts/security/ReentrancyGuard.sol';

import {TokenDistributor} from './TokenDistributor.sol';
import {IStakeFor} from './IStakeFor.sol';

/**
 * @title FeeSharingSystem
 * @notice It handles the distribution of fees using
 * WETH along with the auto-compounding of X2Y2.
 */
contract FeeSharingSystem is ReentrancyGuard, AccessControl, IStakeFor {
    using SafeERC20 for IERC20;

    // for `depositFor` call
    bytes32 public constant DEPOSIT_ROLE = keccak256('DEPOSIT_ROLE');

    // for `updateRewards()`
    bytes32 public constant REWARD_UPDATE_ROLE = keccak256('REWARD_UPDATE_ROLE');

    struct UserInfo {
        uint256 shares; // shares of token staked
        uint256 userRewardPerTokenPaid; // user reward per token paid
        uint256 rewards; // pending rewards
    }

    // Precision factor for calculating rewards and exchange rate
    uint256 public constant PRECISION_FACTOR = 10**18;

    IERC20 public immutable x2y2Token;

    IERC20 public immutable rewardToken;

    TokenDistributor public immutable tokenDistributor;

    // Reward rate (block)
    uint256 public currentRewardPerBlock;

    // Last reward adjustment block number
    uint256 public lastRewardAdjustment;

    // Last update block for rewards
    uint256 public lastUpdateBlock;

    // Current end block for the current reward period
    uint256 public periodEndBlock;

    // Reward per token stored
    uint256 public rewardPerTokenStored;

    // Total existing shares
    uint256 public totalShares;

    mapping(address => UserInfo) public userInfo;

    event Deposit(address indexed user, uint256 amount, uint256 harvestedAmount);
    event Harvest(address indexed user, uint256 harvestedAmount);
    event NewRewardPeriod(uint256 numberBlocks, uint256 rewardPerBlock, uint256 reward);
    event Withdraw(address indexed user, uint256 amount, uint256 harvestedAmount);

    /**
     * @notice Constructor
     * @param _x2y2Token address of the token staked
     * @param _rewardToken address of the reward token
     * @param _tokenDistributor address of the token distributor contract
     */
    constructor(
        address _x2y2Token,
        address _rewardToken,
        address _tokenDistributor
    ) {
        rewardToken = IERC20(_rewardToken);
        x2y2Token = IERC20(_x2y2Token);
        tokenDistributor = TokenDistributor(_tokenDistributor);
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
    }

    /**
     * @notice deposit on behalf of `user`, must be called on fresh deposit only
     * @param user deposit user
     * @param amount amount to deposit
     */
    function depositFor(address user, uint256 amount)
        external
        override
        nonReentrant
        onlyRole(DEPOSIT_ROLE)
        returns (bool)
    {
        require(amount >= PRECISION_FACTOR, 'Deposit: Amount must be >= 1 X2Y2');

        // Auto compounds for everyone
        tokenDistributor.harvestAndCompound();

        // Update reward for user
        _updateReward(user);

        // Retrieve total amount staked by this contract
        (uint256 totalAmountStaked, ) = tokenDistributor.userInfo(address(this));

        // transfer stakingToken from **sender**
        x2y2Token.safeTransferFrom(msg.sender, address(this), amount);

        uint256 currentShares;

        // Calculate the number of shares to issue for the user
        if (totalShares != 0) {
            currentShares = (amount * totalShares) / totalAmountStaked;
            // This is a sanity check to prevent deposit for 0 shares
            require(currentShares != 0, 'Deposit: Fail');
        } else {
            currentShares = amount;
        }

        // Adjust internal shares
        userInfo[user].shares += currentShares;
        totalShares += currentShares;

        // Verify X2Y2 token allowance and adjust if necessary
        _checkAndAdjustX2Y2TokenAllowanceIfRequired(amount, address(tokenDistributor));

        // Deposit user amount in the token distributor contract
        tokenDistributor.deposit(amount);

        emit Deposit(user, amount, 0);

        return true;
    }

    /**
     * @notice Deposit staked tokens (and collect reward tokens if requested)
     * @param amount amount to deposit (in X2Y2)
     * @param claimRewardToken whether to claim reward tokens
     * @dev There is a limit of 1 X2Y2 per deposit to prevent potential manipulation of current shares
     */
    function deposit(uint256 amount, bool claimRewardToken) external nonReentrant {
        require(amount >= PRECISION_FACTOR, 'Deposit: Amount must be >= 1 X2Y2');

        // Auto compounds for everyone
        tokenDistributor.harvestAndCompound();

        // Update reward for user
        _updateReward(msg.sender);

        // Retrieve total amount staked by this contract
        (uint256 totalAmountStaked, ) = tokenDistributor.userInfo(address(this));

        // Transfer X2Y2 tokens to this address
        x2y2Token.safeTransferFrom(msg.sender, address(this), amount);

        uint256 currentShares;

        // Calculate the number of shares to issue for the user
        if (totalShares != 0) {
            currentShares = (amount * totalShares) / totalAmountStaked;
            // This is a sanity check to prevent deposit for 0 shares
            require(currentShares != 0, 'Deposit: Fail');
        } else {
            currentShares = amount;
        }

        // Adjust internal shares
        userInfo[msg.sender].shares += currentShares;
        totalShares += currentShares;

        uint256 pendingRewards;

        if (claimRewardToken) {
            // Fetch pending rewards
            pendingRewards = userInfo[msg.sender].rewards;

            if (pendingRewards > 0) {
                userInfo[msg.sender].rewards = 0;
                rewardToken.safeTransfer(msg.sender, pendingRewards);
            }
        }

        // Verify X2Y2 token allowance and adjust if necessary
        _checkAndAdjustX2Y2TokenAllowanceIfRequired(amount, address(tokenDistributor));

        // Deposit user amount in the token distributor contract
        tokenDistributor.deposit(amount);

        emit Deposit(msg.sender, amount, pendingRewards);
    }

    /**
     * @notice Harvest reward tokens that are pending
     */
    function harvest() external nonReentrant {
        // Auto compounds for everyone
        tokenDistributor.harvestAndCompound();

        // Update reward for user
        _updateReward(msg.sender);

        // Retrieve pending rewards
        uint256 pendingRewards = userInfo[msg.sender].rewards;

        // If pending rewards are null, revert
        require(pendingRewards > 0, 'Harvest: Pending rewards must be > 0');

        // Adjust user rewards and transfer
        userInfo[msg.sender].rewards = 0;

        // Transfer reward token to sender
        rewardToken.safeTransfer(msg.sender, pendingRewards);

        emit Harvest(msg.sender, pendingRewards);
    }

    /**
     * @notice Withdraw staked tokens (and collect reward tokens if requested)
     * @param shares shares to withdraw
     * @param claimRewardToken whether to claim reward tokens
     */
    function withdraw(uint256 shares, bool claimRewardToken) external nonReentrant {
        require(
            (shares > 0) && (shares <= userInfo[msg.sender].shares),
            'Withdraw: Shares equal to 0 or larger than user shares'
        );

        _withdraw(shares, claimRewardToken);
    }

    /**
     * @notice Withdraw all staked tokens (and collect reward tokens if requested)
     * @param claimRewardToken whether to claim reward tokens
     */
    function withdrawAll(bool claimRewardToken) external nonReentrant {
        _withdraw(userInfo[msg.sender].shares, claimRewardToken);
    }

    /**
     * @notice Update the reward per block (in rewardToken)
     * @dev Only callable by owner. Owner is meant to be another smart contract.
     */
    function updateRewards(uint256 reward, uint256 rewardDurationInBlocks)
        external
        onlyRole(REWARD_UPDATE_ROLE)
    {
        // Adjust the current reward per block
        if (block.number >= periodEndBlock) {
            currentRewardPerBlock = reward / rewardDurationInBlocks;
        } else {
            currentRewardPerBlock =
                (reward + ((periodEndBlock - block.number) * currentRewardPerBlock)) /
                rewardDurationInBlocks;
        }

        lastUpdateBlock = block.number;
        periodEndBlock = block.number + rewardDurationInBlocks;

        emit NewRewardPeriod(rewardDurationInBlocks, currentRewardPerBlock, reward);
    }

    /**
     * @notice Calculate pending rewards (WETH) for a user
     * @param user address of the user
     */
    function calculatePendingRewards(address user) external view returns (uint256) {
        return _calculatePendingRewards(user);
    }

    /**
     * @notice Calculate value of X2Y2 for a user given a number of shares owned
     * @param user address of the user
     */
    function calculateSharesValueInX2Y2(address user) external view returns (uint256) {
        // Retrieve amount staked
        (uint256 totalAmountStaked, ) = tokenDistributor.userInfo(address(this));

        // Adjust for pending rewards
        totalAmountStaked += tokenDistributor.calculatePendingRewards(address(this));

        // Return user pro-rata of total shares
        return
            userInfo[user].shares == 0
                ? 0
                : (totalAmountStaked * userInfo[user].shares) / totalShares;
    }

    /**
     * @notice Calculate price of one share (in X2Y2 token)
     * Share price is expressed times 1e18
     */
    function calculateSharePriceInX2Y2() external view returns (uint256) {
        (uint256 totalAmountStaked, ) = tokenDistributor.userInfo(address(this));

        // Adjust for pending rewards
        totalAmountStaked += tokenDistributor.calculatePendingRewards(address(this));

        return
            totalShares == 0
                ? PRECISION_FACTOR
                : (totalAmountStaked * PRECISION_FACTOR) / (totalShares);
    }

    /**
     * @notice Return last block where trading rewards were distributed
     */
    function lastRewardBlock() external view returns (uint256) {
        return _lastRewardBlock();
    }

    /**
     * @notice Calculate pending rewards for a user
     * @param user address of the user
     */
    function _calculatePendingRewards(address user) internal view returns (uint256) {
        return
            ((userInfo[user].shares *
                (_rewardPerToken() - (userInfo[user].userRewardPerTokenPaid))) / PRECISION_FACTOR) +
            userInfo[user].rewards;
    }

    /**
     * @notice Check current allowance and adjust if necessary
     * @param _amount amount to transfer
     * @param _to token to transfer
     */
    function _checkAndAdjustX2Y2TokenAllowanceIfRequired(uint256 _amount, address _to) internal {
        if (x2y2Token.allowance(address(this), _to) < _amount) {
            x2y2Token.approve(_to, type(uint256).max);
        }
    }

    /**
     * @notice Return last block where rewards must be distributed
     */
    function _lastRewardBlock() internal view returns (uint256) {
        return block.number < periodEndBlock ? block.number : periodEndBlock;
    }

    /**
     * @notice Return reward per token
     */
    function _rewardPerToken() internal view returns (uint256) {
        if (totalShares == 0) {
            return rewardPerTokenStored;
        }

        return
            rewardPerTokenStored +
            ((_lastRewardBlock() - lastUpdateBlock) * (currentRewardPerBlock * PRECISION_FACTOR)) /
            totalShares;
    }

    /**
     * @notice Update reward for a user account
     * @param _user address of the user
     */
    function _updateReward(address _user) internal {
        if (block.number != lastUpdateBlock) {
            rewardPerTokenStored = _rewardPerToken();
            lastUpdateBlock = _lastRewardBlock();
        }

        userInfo[_user].rewards = _calculatePendingRewards(_user);
        userInfo[_user].userRewardPerTokenPaid = rewardPerTokenStored;
    }

    /**
     * @notice Withdraw staked tokens (and collect reward tokens if requested)
     * @param shares shares to withdraw
     * @param claimRewardToken whether to claim reward tokens
     */
    function _withdraw(uint256 shares, bool claimRewardToken) internal {
        // Auto compounds for everyone
        tokenDistributor.harvestAndCompound();

        // Update reward for user
        _updateReward(msg.sender);

        // Retrieve total amount staked and calculated current amount (in X2Y2)
        (uint256 totalAmountStaked, ) = tokenDistributor.userInfo(address(this));
        uint256 currentAmount = (totalAmountStaked * shares) / totalShares;

        userInfo[msg.sender].shares -= shares;
        totalShares -= shares;

        // Withdraw amount equivalent in shares
        tokenDistributor.withdraw(currentAmount);

        uint256 pendingRewards;

        if (claimRewardToken) {
            // Fetch pending rewards
            pendingRewards = userInfo[msg.sender].rewards;

            if (pendingRewards > 0) {
                userInfo[msg.sender].rewards = 0;
                rewardToken.safeTransfer(msg.sender, pendingRewards);
            }
        }

        // Transfer X2Y2 tokens to sender
        x2y2Token.safeTransfer(msg.sender, currentAmount);

        emit Withdraw(msg.sender, currentAmount, pendingRewards);
    }
}

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

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (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 `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

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

pragma solidity ^0.8.0;

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

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

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

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

pragma solidity >=0.6.2;

interface IUniswapV2Router01 {
    function factory() external pure returns (address);

    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    )
        external
        returns (
            uint256 amountA,
            uint256 amountB,
            uint256 liquidity
        );

    function addLiquidityETH(
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    )
        external
        payable
        returns (
            uint256 amountToken,
            uint256 amountETH,
            uint256 liquidity
        );

    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountA, uint256 amountB);

    function removeLiquidityETH(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountToken, uint256 amountETH);

    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountA, uint256 amountB);

    function removeLiquidityETHWithPermit(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountToken, uint256 amountETH);

    function swapExactTokensForTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapTokensForExactTokens(
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapExactETHForTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

    function swapTokensForExactETH(
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapExactTokensForETH(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapETHForExactTokens(
        uint256 amountOut,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

    function quote(
        uint256 amountA,
        uint256 reserveA,
        uint256 reserveB
    ) external pure returns (uint256 amountB);

    function getAmountOut(
        uint256 amountIn,
        uint256 reserveIn,
        uint256 reserveOut
    ) external pure returns (uint256 amountOut);

    function getAmountIn(
        uint256 amountOut,
        uint256 reserveIn,
        uint256 reserveOut
    ) external pure returns (uint256 amountIn);

    function getAmountsOut(uint256 amountIn, address[] calldata path)
        external
        view
        returns (uint256[] memory amounts);

    function getAmountsIn(uint256 amountOut, address[] calldata path)
        external
        view
        returns (uint256[] memory amounts);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/AccessControl.sol)

pragma solidity ^0.8.0;

import "./IAccessControl.sol";
import "../utils/Context.sol";
import "../utils/Strings.sol";
import "../utils/introspection/ERC165.sol";

/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping(address => bool) members;
        bytes32 adminRole;
    }

    mapping(bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with a standardized message including the required role.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     *
     * _Available since v4.1._
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role, _msgSender());
        _;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view override returns (bool) {
        return _roles[role].members[account];
    }

    /**
     * @dev Revert with a standard message if `account` is missing `role`.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     */
    function _checkRole(bytes32 role, address account) internal view {
        if (!hasRole(role, account)) {
            revert(
                string(
                    abi.encodePacked(
                        "AccessControl: account ",
                        Strings.toHexString(uint160(account), 20),
                        " is missing role ",
                        Strings.toHexString(uint256(role), 32)
                    )
                )
            );
        }
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view override returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been revoked `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) public virtual override {
        require(account == _msgSender(), "AccessControl: can only renounce roles for self");

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     *
     * NOTE: This function is deprecated in favor of {_grantRole}.
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        bytes32 previousAdminRole = getRoleAdmin(role);
        _roles[role].adminRole = adminRole;
        emit RoleAdminChanged(role, previousAdminRole, adminRole);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * Internal function without access restriction.
     */
    function _grantRole(bytes32 role, address account) internal virtual {
        if (!hasRole(role, account)) {
            _roles[role].members[account] = true;
            emit RoleGranted(role, account, _msgSender());
        }
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * Internal function without access restriction.
     */
    function _revokeRole(bytes32 role, address account) internal virtual {
        if (hasRole(role, account)) {
            _roles[role].members[account] = false;
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import {ReentrancyGuard} from '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import {IERC20, SafeERC20} from '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';

import {IMintableERC20} from './IMintableERC20.sol';

/**
 * @title TokenDistributor
 * @notice It handles the distribution of X2Y2 token.
 * It auto-adjusts block rewards over a set number of periods.
 */
contract TokenDistributor is ReentrancyGuard {
    using SafeERC20 for IERC20;
    using SafeERC20 for IMintableERC20;

    struct StakingPeriod {
        uint256 rewardPerBlockForStaking;
        uint256 rewardPerBlockForOthers;
        uint256 periodLengthInBlock;
    }

    struct UserInfo {
        uint256 amount; // Amount of staked tokens provided by user
        uint256 rewardDebt; // Reward debt
    }

    // Precision factor for calculating rewards
    uint256 public constant PRECISION_FACTOR = 10**12;

    IMintableERC20 public immutable x2y2Token;

    address public immutable tokenSplitter;

    // Number of reward periods
    uint256 public immutable NUMBER_PERIODS;

    // Block number when rewards start
    uint256 public immutable START_BLOCK;

    // Accumulated tokens per share
    uint256 public accTokenPerShare;

    // Current phase for rewards
    uint256 public currentPhase;

    // Block number when rewards end
    uint256 public endBlock;

    // Block number of the last update
    uint256 public lastRewardBlock;

    // Tokens distributed per block for other purposes (team + treasury + trading rewards)
    uint256 public rewardPerBlockForOthers;

    // Tokens distributed per block for staking
    uint256 public rewardPerBlockForStaking;

    // Total amount staked
    uint256 public totalAmountStaked;

    mapping(uint256 => StakingPeriod) public stakingPeriod;

    mapping(address => UserInfo) public userInfo;

    event Compound(address indexed user, uint256 harvestedAmount);
    event Deposit(address indexed user, uint256 amount, uint256 harvestedAmount);
    event NewRewardsPerBlock(
        uint256 indexed currentPhase,
        uint256 startBlock,
        uint256 rewardPerBlockForStaking,
        uint256 rewardPerBlockForOthers
    );
    event Withdraw(address indexed user, uint256 amount, uint256 harvestedAmount);

    /**
     * @notice Constructor
     * @param _x2y2Token token address
     * @param _tokenSplitter token splitter contract address (for team and trading rewards)
     * @param _startBlock start block for reward program
     * @param _rewardsPerBlockForStaking array of rewards per block for staking
     * @param _rewardsPerBlockForOthers array of rewards per block for other purposes (team + treasury + trading rewards)
     * @param _periodLengthesInBlocks array of period lengthes
     * @param _numberPeriods number of periods with different rewards/lengthes (e.g., if 3 changes --> 4 periods)
     */
    constructor(
        address _x2y2Token,
        address _tokenSplitter,
        uint256 _startBlock,
        uint256[] memory _rewardsPerBlockForStaking,
        uint256[] memory _rewardsPerBlockForOthers,
        uint256[] memory _periodLengthesInBlocks,
        uint256 _numberPeriods
    ) {
        require(
            (_periodLengthesInBlocks.length == _numberPeriods) &&
                (_rewardsPerBlockForStaking.length == _numberPeriods) &&
                (_rewardsPerBlockForStaking.length == _numberPeriods),
            'Distributor: Lengthes must match numberPeriods'
        );

        // 1. Operational checks for supply
        uint256 nonCirculatingSupply = IMintableERC20(_x2y2Token).SUPPLY_CAP() -
            IMintableERC20(_x2y2Token).totalSupply();

        uint256 amountTokensToBeMinted;

        for (uint256 i = 0; i < _numberPeriods; i++) {
            amountTokensToBeMinted +=
                (_rewardsPerBlockForStaking[i] * _periodLengthesInBlocks[i]) +
                (_rewardsPerBlockForOthers[i] * _periodLengthesInBlocks[i]);

            stakingPeriod[i] = StakingPeriod({
                rewardPerBlockForStaking: _rewardsPerBlockForStaking[i],
                rewardPerBlockForOthers: _rewardsPerBlockForOthers[i],
                periodLengthInBlock: _periodLengthesInBlocks[i]
            });
        }

        require(
            amountTokensToBeMinted == nonCirculatingSupply,
            'Distributor: Wrong reward parameters'
        );

        // 2. Store values
        x2y2Token = IMintableERC20(_x2y2Token);
        tokenSplitter = _tokenSplitter;
        rewardPerBlockForStaking = _rewardsPerBlockForStaking[0];
        rewardPerBlockForOthers = _rewardsPerBlockForOthers[0];

        START_BLOCK = _startBlock;
        endBlock = _startBlock + _periodLengthesInBlocks[0];

        NUMBER_PERIODS = _numberPeriods;

        // Set the lastRewardBlock as the startBlock
        lastRewardBlock = _startBlock;
    }

    /**
     * @notice Deposit staked tokens and compounds pending rewards
     * @param amount amount to deposit (in X2Y2)
     */
    function deposit(uint256 amount) external nonReentrant {
        require(amount > 0, 'Deposit: Amount must be > 0');
        require(block.number >= START_BLOCK, 'Deposit: Not started yet');

        // Update pool information
        _updatePool();

        // Transfer X2Y2 tokens to this contract
        x2y2Token.safeTransferFrom(msg.sender, address(this), amount);

        uint256 pendingRewards;

        // If not new deposit, calculate pending rewards (for auto-compounding)
        if (userInfo[msg.sender].amount > 0) {
            pendingRewards =
                ((userInfo[msg.sender].amount * accTokenPerShare) / PRECISION_FACTOR) -
                userInfo[msg.sender].rewardDebt;
        }

        // Adjust user information
        userInfo[msg.sender].amount += (amount + pendingRewards);
        userInfo[msg.sender].rewardDebt =
            (userInfo[msg.sender].amount * accTokenPerShare) /
            PRECISION_FACTOR;

        // Increase totalAmountStaked
        totalAmountStaked += (amount + pendingRewards);

        emit Deposit(msg.sender, amount, pendingRewards);
    }

    /**
     * @notice Compound based on pending rewards
     */
    function harvestAndCompound() external nonReentrant {
        // Update pool information
        _updatePool();

        // Calculate pending rewards
        uint256 pendingRewards = ((userInfo[msg.sender].amount * accTokenPerShare) /
            PRECISION_FACTOR) - userInfo[msg.sender].rewardDebt;

        // Return if no pending rewards
        if (pendingRewards == 0) {
            // It doesn't throw revertion (to help with the fee-sharing auto-compounding contract)
            return;
        }

        // Adjust user amount for pending rewards
        userInfo[msg.sender].amount += pendingRewards;

        // Adjust totalAmountStaked
        totalAmountStaked += pendingRewards;

        // Recalculate reward debt based on new user amount
        userInfo[msg.sender].rewardDebt =
            (userInfo[msg.sender].amount * accTokenPerShare) /
            PRECISION_FACTOR;

        emit Compound(msg.sender, pendingRewards);
    }

    /**
     * @notice Update pool rewards
     */
    function updatePool() external nonReentrant {
        _updatePool();
    }

    /**
     * @notice Withdraw staked tokens and compound pending rewards
     * @param amount amount to withdraw
     */
    function withdraw(uint256 amount) external nonReentrant {
        require(
            (userInfo[msg.sender].amount >= amount) && (amount > 0),
            'Withdraw: Amount must be > 0 or lower than user balance'
        );

        // Update pool
        _updatePool();

        // Calculate pending rewards
        uint256 pendingRewards = ((userInfo[msg.sender].amount * accTokenPerShare) /
            PRECISION_FACTOR) - userInfo[msg.sender].rewardDebt;

        // Adjust user information
        userInfo[msg.sender].amount = userInfo[msg.sender].amount + pendingRewards - amount;
        userInfo[msg.sender].rewardDebt =
            (userInfo[msg.sender].amount * accTokenPerShare) /
            PRECISION_FACTOR;

        // Adjust total amount staked
        totalAmountStaked = totalAmountStaked + pendingRewards - amount;

        // Transfer X2Y2 tokens to the sender
        x2y2Token.safeTransfer(msg.sender, amount);

        emit Withdraw(msg.sender, amount, pendingRewards);
    }

    /**
     * @notice Withdraw all staked tokens and collect tokens
     */
    function withdrawAll() external nonReentrant {
        require(userInfo[msg.sender].amount > 0, 'Withdraw: Amount must be > 0');

        // Update pool
        _updatePool();

        // Calculate pending rewards and amount to transfer (to the sender)
        uint256 pendingRewards = ((userInfo[msg.sender].amount * accTokenPerShare) /
            PRECISION_FACTOR) - userInfo[msg.sender].rewardDebt;

        uint256 amountToTransfer = userInfo[msg.sender].amount + pendingRewards;

        // Adjust total amount staked
        totalAmountStaked = totalAmountStaked - userInfo[msg.sender].amount;

        // Adjust user information
        userInfo[msg.sender].amount = 0;
        userInfo[msg.sender].rewardDebt = 0;

        // Transfer X2Y2 tokens to the sender
        x2y2Token.safeTransfer(msg.sender, amountToTransfer);

        emit Withdraw(msg.sender, amountToTransfer, pendingRewards);
    }

    /**
     * @notice Calculate pending rewards for a user
     * @param user address of the user
     * @return Pending rewards
     */
    function calculatePendingRewards(address user) external view returns (uint256) {
        if ((block.number > lastRewardBlock) && (totalAmountStaked != 0)) {
            uint256 multiplier = _getMultiplier(lastRewardBlock, block.number);

            uint256 tokenRewardForStaking = multiplier * rewardPerBlockForStaking;

            uint256 adjustedEndBlock = endBlock;
            uint256 adjustedCurrentPhase = currentPhase;

            // Check whether to adjust multipliers and reward per block
            while (
                (block.number > adjustedEndBlock) && (adjustedCurrentPhase < (NUMBER_PERIODS - 1))
            ) {
                // Update current phase
                adjustedCurrentPhase++;

                // Update rewards per block
                uint256 adjustedRewardPerBlockForStaking = stakingPeriod[adjustedCurrentPhase]
                    .rewardPerBlockForStaking;

                // Calculate adjusted block number
                uint256 previousEndBlock = adjustedEndBlock;

                // Update end block
                adjustedEndBlock =
                    previousEndBlock +
                    stakingPeriod[adjustedCurrentPhase].periodLengthInBlock;

                // Calculate new multiplier
                uint256 newMultiplier = (block.number <= adjustedEndBlock)
                    ? (block.number - previousEndBlock)
                    : stakingPeriod[adjustedCurrentPhase].periodLengthInBlock;

                // Adjust token rewards for staking
                tokenRewardForStaking += (newMultiplier * adjustedRewardPerBlockForStaking);
            }

            uint256 adjustedTokenPerShare = accTokenPerShare +
                (tokenRewardForStaking * PRECISION_FACTOR) /
                totalAmountStaked;

            return
                (userInfo[user].amount * adjustedTokenPerShare) /
                PRECISION_FACTOR -
                userInfo[user].rewardDebt;
        } else {
            return
                (userInfo[user].amount * accTokenPerShare) /
                PRECISION_FACTOR -
                userInfo[user].rewardDebt;
        }
    }

    /**
     * @notice Update reward variables of the pool
     */
    function _updatePool() internal {
        if (block.number <= lastRewardBlock) {
            return;
        }

        if (totalAmountStaked == 0) {
            lastRewardBlock = block.number;
            return;
        }

        // Calculate multiplier
        uint256 multiplier = _getMultiplier(lastRewardBlock, block.number);

        // Calculate rewards for staking and others
        uint256 tokenRewardForStaking = multiplier * rewardPerBlockForStaking;
        uint256 tokenRewardForOthers = multiplier * rewardPerBlockForOthers;

        // Check whether to adjust multipliers and reward per block
        while ((block.number > endBlock) && (currentPhase < (NUMBER_PERIODS - 1))) {
            // Update rewards per block
            _updateRewardsPerBlock(endBlock);

            uint256 previousEndBlock = endBlock;

            // Adjust the end block
            endBlock += stakingPeriod[currentPhase].periodLengthInBlock;

            // Adjust multiplier to cover the missing periods with other lower inflation schedule
            uint256 newMultiplier = _getMultiplier(previousEndBlock, block.number);

            // Adjust token rewards
            tokenRewardForStaking += (newMultiplier * rewardPerBlockForStaking);
            tokenRewardForOthers += (newMultiplier * rewardPerBlockForOthers);
        }

        // Mint tokens only if token rewards for staking are not null
        if (tokenRewardForStaking > 0) {
            // It allows protection against potential issues to prevent funds from being locked
            bool mintStatus = x2y2Token.mint(address(this), tokenRewardForStaking);
            if (mintStatus) {
                accTokenPerShare =
                    accTokenPerShare +
                    ((tokenRewardForStaking * PRECISION_FACTOR) / totalAmountStaked);
            }

            x2y2Token.mint(tokenSplitter, tokenRewardForOthers);
        }

        // Update last reward block only if it wasn't updated after or at the end block
        if (lastRewardBlock <= endBlock) {
            lastRewardBlock = block.number;
        }
    }

    /**
     * @notice Update rewards per block
     * @dev Rewards are halved by 2 (for staking + others)
     */
    function _updateRewardsPerBlock(uint256 _newStartBlock) internal {
        // Update current phase
        currentPhase++;

        // Update rewards per block
        rewardPerBlockForStaking = stakingPeriod[currentPhase].rewardPerBlockForStaking;
        rewardPerBlockForOthers = stakingPeriod[currentPhase].rewardPerBlockForOthers;

        emit NewRewardsPerBlock(
            currentPhase,
            _newStartBlock,
            rewardPerBlockForStaking,
            rewardPerBlockForOthers
        );
    }

    /**
     * @notice Return reward multiplier over the given "from" to "to" block.
     * @param from block to start calculating reward
     * @param to block to finish calculating reward
     * @return the multiplier for the period
     */
    function _getMultiplier(uint256 from, uint256 to) internal view returns (uint256) {
        if (to <= endBlock) {
            return to - from;
        } else if (from >= endBlock) {
            return 0;
        } else {
            return endBlock - from;
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

interface IStakeFor {
    function depositFor(address user, uint256 amount) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)

pragma solidity ^0.8.0;

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) external;
}

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

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}

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

pragma solidity ^0.8.0;

import "./IERC165.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

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

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol';

interface IMintableERC20 is IERC20 {
    function SUPPLY_CAP() external view returns (uint256);

    function mint(address account, uint256 amount) external returns (bool);
}

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract FeeSharingSystem","name":"_feeSharingSystem","type":"address"},{"internalType":"contract IUniswapV2Router02","name":"_uniswapRouter","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amountSold","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountReceived","type":"uint256"}],"name":"ConversionToX2Y2","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[],"name":"FailedConversion","type":"event"},{"anonymous":false,"inputs":[],"name":"HarvestStart","type":"event"},{"anonymous":false,"inputs":[],"name":"HarvestStop","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"harvestBufferBlocks","type":"uint256"}],"name":"NewHarvestBufferBlocks","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"NewMaximumPriceX2Y2InWETH","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"thresholdAmount","type":"uint256"}],"name":"NewThresholdAmount","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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"MAXIMUM_HARVEST_BUFFER_BLOCKS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINIMUM_DEPOSIT_X2Y2","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"calculateSharePriceInPrimeShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"calculateSharePriceInX2Y2","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"calculateSharesValueInX2Y2","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"canHarvest","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"checkAndAdjustRewardTokenAllowanceIfRequired","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"checkAndAdjustX2Y2TokenAllowanceIfRequired","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeSharingSystem","outputs":[{"internalType":"contract FeeSharingSystem","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"harvestAndSellAndCompound","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"harvestBufferBlocks","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastHarvestBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxPriceX2Y2InWETH","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"startHarvest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stopHarvest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"thresholdAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uniswapRouter","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newHarvestBufferBlocks","type":"uint256"}],"name":"updateHarvestBufferBlocks","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newMaxPriceX2Y2InWETH","type":"uint256"}],"name":"updateMaxPriceOfX2Y2InWETH","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newThresholdAmount","type":"uint256"}],"name":"updateThresholdAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"x2y2Token","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

000000000000000000000000c8c3cc5be962b6d281e4a53dbcce1359f76a1b850000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d

-----Decoded View---------------
Arg [0] : _feeSharingSystem (address): 0xc8C3CC5be962b6D281E4a53DBcCe1359F76a1B85
Arg [1] : _uniswapRouter (address): 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000c8c3cc5be962b6d281e4a53dbcce1359f76a1b85
Arg [1] : 0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d