// SPDX-License-Identifier: GPL-3.0
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;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/GSN/Context.sol
/*
 * @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) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

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

import './IERC20.sol';
import './IERC20Metadata.sol';
import './Context.sol';

contract ERC20 is Context,IERC20,IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5,05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
        unchecked {
            _approve(sender, _msgSender(), currentAllowance - amount);
        }

        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(_msgSender(), spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[sender] = senderBalance - amount;
        }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

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

interface IDeployMiningPoolParams {
    struct DeployMiningPoolParams {
        address factory;
        address creator;
        address pair;
        address stableToken;
        address mintToken;
        uint epochReleaseRate;
        uint epochBlocks;
        uint startBlock;
        uint sellUserRate;
        uint sellBuybackRate;
        uint32 rateForLPH;
        uint32 rateForTH;
        uint32 rateForTS;
        uint32 rateForDev;
    }
}

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

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol
/**
 * @dev Interface of the ERC20 standard as defined in the EIP. Does not include
 * the optional functions; to access them see {ERC20Detailed}.
 */
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

pragma solidity ^0.8.0;

import "./IERC20.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

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

import './IDeployMiningPoolParams.sol';

interface IPoolFactory is IDeployMiningPoolParams {
    function deployParams() external view returns(DeployMiningPoolParams memory paras);
    function factoryOwner() external view returns(address);
    function swapRouter() external view returns(address);
    function miningPoolsLength() external view returns(uint256);
    function miningPools(uint256 index) external view returns(address);
    function pair2miningPool(address pair) external view returns(address);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

interface ISwapRouter {
    function createPair(
        address mintToken,
        uint256 mintTokenAmount,
        address stableToken,
        uint256 stableTokenAmount,
        uint256 sellBurnRate,
        uint256 sellStopBurnSupply
    ) external;
    function setPoolFactory(address _poolFactory) external;
    function pairFor(address tokenA, address tokenB) external view returns (address pair);
    function factory() external view returns(address);
    function WETH() external view returns(address);
    function baseTokenOf(address pair) external view returns(address);
    function sellBurnRateOf(address pair) external view returns(uint);
    function sellStopBurnSupplyOf(address pair) external view returns(uint);
    function isWhiteList(address pair,address account) external view returns(bool);
    function setWhiteList(address pair,address account,bool status) external;
    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external;
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external;
    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory);
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.5.0;

interface IWETH {
    function deposit() external payable;
    function transfer(address to, uint value) external returns (bool);
    function withdraw(uint) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The tree and the proofs can be generated using our
 * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
 * You will find a quickstart guide in the readme.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the merkle tree could be reinterpreted as a leaf value.
 * OpenZeppelin's JavaScript library generates merkle trees that are safe
 * against this attack out of the box.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Calldata version of {verify}
     *
     * _Available since v4.7._
     */
    function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProofCalldata(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * _Available since v4.4._
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Calldata version of {processProof}
     *
     * _Available since v4.7._
     */
    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     *
     * _Available since v4.7._
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Calldata version of {processMultiProof}.
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

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

import './libs/Utils.sol';
import './libs/IWETH.sol';
import './libs/ISwapRouter.sol';
import './libs/IPoolFactory.sol';
import './libs/IDeployMiningPoolParams.sol';
import './libs/SafeERC20.sol';
import './libs/SafeMath.sol';
import './libs/ERC20.sol';

contract MiningPool is IDeployMiningPoolParams {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    uint public constant RATE_PERCISION = 10000;
    uint public constant UNIT_PERCISION = 1e12;

    bool public migrateDiscard;

    address public dev;
    uint256 public devClaimedMintToken;
    uint256 public devClaimedStableToken;
    address public migrator;
    address public creator;
    address public rooter;
    uint256 public epochReleaseRate;
    uint256 public epoch;

    address public immutable factory;
    address public immutable pair;
    address public immutable stableToken;
    address public immutable mintToken;
    uint256 public immutable epochBlocks;
    uint256 public immutable startBlock;

    uint256 public totalLPH;
    uint256 public totalInvested;
    uint256 public usersBalance;
    uint256 public usersUnitAcc;

    uint256 public sellUserRate;
    uint256 public sellBuybackRate;

    struct User {
        address leader;
        uint256 level;
        uint256 lph;
        uint256 investedAcc;
        uint256 rewardAcc;
        uint256 referencesRewardAcc;
        uint256 rewardDebt;
    }

    mapping(address => address[]) public references;
    mapping(address => uint256[2]) public claimedRewards;
    mapping(uint256 => bytes32) public merkleRoots; // epoch -> merkleRoot
    mapping(address => User) public users;
    uint256[4] public assignRewardsAcc;
    uint256[4] public assignRewardsRate;
    address[] public accounts;

    event ClaimTHTSRewards(address account, address token, uint thRewards, uint tsRewards, uint blockTime);
    event ReleaseRewards(uint removedLpAmount, uint remainLpAmount, uint rewardAmount, uint blockTime, uint epoch);
    event Buy(address account, uint amountIn, uint lph, uint blockTime);
    event Harvested(address account, uint amount, uint blockTime);
    event NewUser(address account, address leader);

    modifier onlyCreator() {
        require(msg.sender == creator, "caller must be creator");
        _;
    }
    
    modifier onlyFactoryOwner() {
        require(msg.sender == IPoolFactory(factory).factoryOwner(), "caller must be creator");
        _;
    }

    modifier onlyRooter() {
        require(msg.sender == rooter, "Caller is not rooter");
        _;
    }

    constructor() {
        DeployMiningPoolParams memory params = IPoolFactory(msg.sender).deployParams();
        factory = params.factory;
        creator = tx.origin;
        rooter = params.creator;
        pair = params.pair;
        stableToken = params.stableToken;
        mintToken = params.mintToken;
        epochReleaseRate = params.epochReleaseRate;
        epochBlocks = params.epochBlocks;
        startBlock = params.startBlock;
        sellUserRate = params.sellUserRate;
        sellBuybackRate = params.sellBuybackRate;
        dev = tx.origin;
        assignRewardsRate[0] = params.rateForLPH;
        assignRewardsRate[1] = uint256(params.rateForTH);
        assignRewardsRate[2] = uint256(params.rateForTS);
        assignRewardsRate[3] = uint256(params.rateForDev);

        address router = IPoolFactory(msg.sender).swapRouter();
        IERC20(params.stableToken).safeApprove(router,type(uint256).max); 
        IERC20(params.mintToken).safeApprove(router,type(uint256).max);
        IERC20(params.pair).safeApprove(router,type(uint256).max);
    }

    function setRooter(address newRooter) public onlyFactoryOwner {
        require(newRooter != address(0), "Invalid newRooter");
        rooter = newRooter;
    }

    function setMerkleRoot(uint256 _epoch, bytes32 merkleRoot) public onlyRooter {
        merkleRoots[_epoch] = merkleRoot;
    }

    function buy(uint amount, address leader) public {
        require(amount == 0 || amount >= 20 * 10 ** ERC20(stableToken).decimals(), "Invalid amount #1");
        buy2(amount, leader, msg.sender);
    }

    function buy2(uint amount, address leader, address receiver) public {
        require(amount == 0 || amount >= 10 ** ERC20(stableToken).decimals(), "Invalid amount #2");
        buy3(amount, leader, receiver);
    }

    function buy3(uint amount, address leader, address receiver) internal {
        User storage user = users[receiver];
        // New user, Set leader
        if(user.leader == address(0) && accounts.length == 0){
            require(amount > 0, "Invalid amount #3");
            require(receiver == creator, "The first user must be creator");
            accounts.push(receiver);
            user.leader = address(1);
            user.level = 1;
            emit NewUser(receiver, address(1));
        }else if(user.leader == address(0)){
            require(users[leader].lph > 0, "Invalid leader");
            require(amount > 0, "Invalid amount #4");
            user.level = users[leader].level.add(1);
            user.leader = leader;
            accounts.push(receiver);
            references[leader].push(receiver);
            emit NewUser(receiver, leader);
        }
        // Reward
        if (user.lph > 0){
            uint256 pending = user.lph.mul(usersUnitAcc).div(UNIT_PERCISION) - user.rewardDebt;
            if (pending > 0 && usersBalance >= pending) {
                usersBalance = usersBalance.sub(pending);
                IERC20(mintToken).safeTransfer(receiver, pending);
                user.rewardAcc = user.rewardAcc.add(pending);
                users[user.leader].referencesRewardAcc = users[user.leader].referencesRewardAcc.add(pending);
                emit Harvested(receiver, pending, block.timestamp);
            }
        }
        // invest
        if (amount > 0) {
            uint receivedAmount = _transferFrom(msg.sender, stableToken, amount);
            _addLiquidity(receivedAmount);
            // calc lph
            uint256 lph = getLPH(receivedAmount);
            user.lph = user.lph.add(lph);
            totalLPH = totalLPH.add(lph);
            totalInvested = totalInvested.add(receivedAmount);
            user.investedAcc = user.investedAcc.add(receivedAmount);
            emit Buy(receiver, receivedAmount, lph, block.timestamp);
        }
        users[receiver].rewardDebt = usersUnitAcc.mul(users[receiver].lph).div(UNIT_PERCISION);
    }

    function sell(uint amount) external {
        require(amount > 0, "Invalid amount");
        uint receivedAmount = _transferFrom(msg.sender, mintToken, amount);
        ISwapRouter router = ISwapRouter(IPoolFactory(factory).swapRouter());
        address[] memory path = new address[](2);
        path[0] = mintToken;
        path[1] = stableToken;
        uint balanceBefore = IERC20(stableToken).balanceOf(address(this));
        router.swapExactTokensForTokensSupportingFeeOnTransferTokens(receivedAmount, 1, path, address(this), type(uint256).max);
        uint swapedAmount = IERC20(stableToken).balanceOf(address(this)).sub(balanceBefore);
        IERC20(stableToken).safeTransfer(msg.sender, swapedAmount.mul(sellUserRate) / RATE_PERCISION);
        buy3(swapedAmount.mul(sellBuybackRate) / RATE_PERCISION, address(0), msg.sender);
    }

    function claimLPHRewards() external {
        buy(0, address(0));
    }

    function claimTHTSRewards(uint _epoch, uint thRewardAcc, uint tsRewardAcc, bytes32[] calldata merkleProof) external {
        require(Utils.verify(msg.sender, thRewardAcc, tsRewardAcc, merkleRoots[_epoch], merkleProof), "Validation failure");
        require(merkleRoots[_epoch] != bytes32(0), "Waiting for `merkleRoots[epoch]` to be set.");
        require(thRewardAcc >= claimedRewards[msg.sender][0], "Invalid thRewardAcc");
        require(tsRewardAcc >= claimedRewards[msg.sender][1], "Invalid tsRewardAcc");
        require(users[msg.sender].lph > 0, "account not invested");
        uint256 rewards0 = thRewardAcc.sub(claimedRewards[msg.sender][0]);
        uint256 rewards1 = tsRewardAcc.sub(claimedRewards[msg.sender][1]);
        uint256 totalRewards = rewards0.add(rewards1);
        require(IERC20(mintToken).balanceOf(address(this)).sub(usersBalance) >= totalRewards, "Insufficient balance");
        claimedRewards[msg.sender][0] = thRewardAcc;
        claimedRewards[msg.sender][1] = tsRewardAcc;
        IERC20(mintToken).safeTransfer(msg.sender, totalRewards);
        emit ClaimTHTSRewards(msg.sender, mintToken, rewards0, rewards1, block.timestamp);
    }



    function releaseCheck() external view returns (uint256 curEpochIndex, bool canRelease) {
        curEpochIndex = epoch;
        canRelease = block.number > startBlock && (block.number.sub(startBlock + epochBlocks.mul(epoch))) > epochBlocks;
    }

    function releaseRewards() external {
        uint rateForLPH = assignRewardsRate[0];
        uint rateForTH = assignRewardsRate[1];
        uint rateForTS = assignRewardsRate[2];
        uint rateForDev = assignRewardsRate[3];
        require(rateForLPH + rateForTH + rateForTS + rateForDev == 100, "Invalid assignRewardsRate");
        require(block.number > startBlock && (block.number.sub(startBlock + epochBlocks.mul(epoch))) > epochBlocks, "Disable release future rewards.");

        uint lpAmount = IERC20(pair).balanceOf(address(this)).mul(epochReleaseRate) / RATE_PERCISION;
        uint balanceBefore = IERC20(mintToken).balanceOf(address(this));
        _removeLiquidityForRewards(lpAmount);
        uint rewardAmount = IERC20(mintToken).balanceOf(address(this)).sub(balanceBefore);
        require(rewardAmount > 0, "Invalid rewardAmount");

        uint rewardForLPH = rewardAmount.mul(rateForLPH).div(100);
        usersUnitAcc = usersUnitAcc.add(rewardForLPH.mul(UNIT_PERCISION).div(totalLPH));
        usersBalance = usersBalance.add(rewardForLPH);
        
        uint rewardForDev = rewardAmount.mul(rateForDev).div(100);

        assignRewardsAcc[0] = assignRewardsAcc[0].add(rewardForLPH); // LPH
        assignRewardsAcc[1] = assignRewardsAcc[1].add(rewardAmount.mul(rateForTH).div(100)); // TH
        assignRewardsAcc[2] = assignRewardsAcc[2].add(rewardAmount.mul(rateForTS).div(100)); // TS
        assignRewardsAcc[3] = assignRewardsAcc[3].add(rewardForDev); // Dev

        epoch = epoch.add(1);
        emit ReleaseRewards(lpAmount, IERC20(pair).balanceOf(address(this)), rewardAmount, block.timestamp, epoch);
    }

    function setDev(address _dev) public onlyCreator {
        dev = _dev;
    }

    function devClaimRewardsFromRelease(uint256 amount) public {
        require(msg.sender == dev, "caller must be dev");
        require(amount > 0 && amount <= assignRewardsAcc[3].sub(devClaimedMintToken), "Invalid amount");
        devClaimedMintToken = devClaimedMintToken.add(amount);
        IERC20(mintToken).safeTransfer(dev, amount);
    }

    function devClaimRewardsFromSale(uint256 amount) public {
        require(msg.sender == dev, "caller must be dev");
        require(amount > 0 && amount <= IERC20(stableToken).balanceOf(address(this)), "Invalid amount");
        devClaimedStableToken = devClaimedStableToken.add(amount);
        IERC20(stableToken).safeTransfer(dev, amount);
    }
    
    function _transferFrom(address from,address token,uint amount) internal returns(uint receivedAmount){
        uint beforeBalance = IERC20(token).balanceOf(address(this));
        IERC20(token).safeTransferFrom(from, address(this), amount);
        return IERC20(token).balanceOf(address(this)).sub(beforeBalance);
    }

    function _addLiquidity(uint _amount) internal {
        uint amountHalf = _amount / 2;
        ISwapRouter router = ISwapRouter(IPoolFactory(factory).swapRouter());
        address[] memory path = new address[](2);
        path[0] = stableToken;
        path[1] = mintToken;
        uint balanceBefore = IERC20(mintToken).balanceOf(address(this));
        router.swapExactTokensForTokensSupportingFeeOnTransferTokens(amountHalf,1,path,address(this),type(uint256).max);
        uint swapedAmount = IERC20(mintToken).balanceOf(address(this)).sub(balanceBefore);
        router.addLiquidity(stableToken, mintToken, amountHalf, swapedAmount, 1, 1, address(this), type(uint256).max);
    }

    function _removeLiquidityForRewards(uint lpAmount) internal {
        if(lpAmount == 0){
            return;
        }
        ISwapRouter router = ISwapRouter(IPoolFactory(factory).swapRouter());
        router.removeLiquidity(stableToken, mintToken, lpAmount, 1, 1, address(this), type(uint256).max);
        address[] memory path = new address[](2);
        path[0] = stableToken;
        path[1] = mintToken;
        router.swapExactTokensForTokensSupportingFeeOnTransferTokens(IERC20(path[0]).balanceOf(address(this)),1,path,address(this),type(uint256).max);
    }

    function transferCreator(address newCreator) external onlyCreator {
        require(newCreator != address(0),"new creator can not be address 0");
        creator = newCreator;
    }

    function getClaimedRewards(address account) external view returns (uint256[2] memory) {
        return claimedRewards[account];
    }

    function getAssignRewardsAcc() external view returns (uint256[4] memory) {
        return assignRewardsAcc;
    }

    function getReferences(address leader, uint startPos) external view
    returns (uint length, address[] memory data) {
        address[] memory refs = references[leader];
        length = uint(refs.length);
        if(startPos >= length) {
            return (length, new address[](0));
        }
        uint256 endPos = startPos + 10;
        if(endPos > length){
            endPos = length;
        }
        data = new address[](endPos - startPos);
        for(uint i = 0; i < 10 && (i+startPos) < endPos; i++) {
            data[i] = refs[i+startPos];
        }
    }

    function accountsCount() external view returns (uint) {
        return accounts.length;
    }

    function referencesCount(address account) external view returns (uint256) {
        return references[account].length;
    }

    function getLPH(uint256 amount) public view returns(uint256) {
        uint256 epochs = startBlock > block.number ? 0 : (block.number - startBlock) / epochBlocks;
        uint256 rise = Utils.lphRise(epochs);
        return amount.mul(rise).div(10 ** ERC20(stableToken).decimals() * 100);
    }

    function getLPHRewardAcc(address account) external view returns (uint256) {
        User storage user = users[account];
        if (user.lph == 0){
            return 0;
        }
        return user.lph.mul(usersUnitAcc).div(UNIT_PERCISION).sub(user.rewardDebt).add(user.rewardAcc);
    }

}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC20.sol";
import "./Address.sol";

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

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

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

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.5.16;

library SafeMath {
    uint256 constant WAD = 10 ** 18;
    uint256 constant RAY = 10 ** 27;

    function wad() public pure returns (uint256) {
        return WAD;
    }

    function ray() public pure returns (uint256) {
        return RAY;
    }

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }

    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a <= b ? a : b;
    }

    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    function sqrt(uint256 a) internal pure returns (uint256 b) {
        if (a > 3) {
            b = a;
            uint256 x = a / 2 + 1;
            while (x < b) {
                b = x;
                x = (a / x + x) / 2;
            }
        } else if (a != 0) {
            b = 1;
        }
    }

    function wmul(uint256 a, uint256 b) internal pure returns (uint256) {
        return mul(a, b) / WAD;
    }

    function wmulRound(uint256 a, uint256 b) internal pure returns (uint256) {
        return add(mul(a, b), WAD / 2) / WAD;
    }

    function rmul(uint256 a, uint256 b) internal pure returns (uint256) {
        return mul(a, b) / RAY;
    }

    function rmulRound(uint256 a, uint256 b) internal pure returns (uint256) {
        return add(mul(a, b), RAY / 2) / RAY;
    }

    function wdiv(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(mul(a, WAD), b);
    }

    function wdivRound(uint256 a, uint256 b) internal pure returns (uint256) {
        return add(mul(a, WAD), b / 2) / b;
    }

    function rdiv(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(mul(a, RAY), b);
    }

    function rdivRound(uint256 a, uint256 b) internal pure returns (uint256) {
        return add(mul(a, RAY), b / 2) / b;
    }

    function wpow(uint256 x, uint256 n) internal pure returns (uint256) {
        uint256 result = WAD;
        while (n > 0) {
            if (n % 2 != 0) {
                result = wmul(result, x);
            }
            x = wmul(x, x);
            n /= 2;
        }
        return result;
    }

    function rpow(uint256 x, uint256 n) internal pure returns (uint256) {
        uint256 result = RAY;
        while (n > 0) {
            if (n % 2 != 0) {
                result = rmul(result, x);
            }
            x = rmul(x, x);
            n /= 2;
        }
        return result;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import './MerkleProof.sol';

library Utils {
    function lphRise(uint256 _epoch) internal pure returns(uint256) {
        if(_epoch == 0){
            return 10000;
        }
        uint256 base = 10100;
        uint256 result = 1;
        while (_epoch > 0) {
            if (_epoch % 2 == 1) {
                if(result > 1){
                    result = result * base / 10000;
                }else{
                    result = result * base;
                }
            }
            base = base * base / 10000;
            _epoch = _epoch / 2;
        }
        return result;
    }

    function verify(address account, uint256 thRewardAcc, uint256 tsRewardAcc, bytes32 merkleRoot, bytes32[] calldata merkleProof) internal pure returns(bool) {
        bytes32 node = keccak256(abi.encodePacked(account, thRewardAcc, tsRewardAcc));
        return MerkleProof.verifyCalldata(merkleProof, merkleRoot, node);
    }
}

{
  "compilationTarget": {
    "contracts/MiningPool.sol": "MiningPool"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}