Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library Math
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionCallWithValue(addres ...
•    - function _functionCallWithValue(addre ...
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeApprove(IERC20 token, ad ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function _callOptionalReturn(IERC20 t ...
• interface ILPPool
•    - function mir()
•    - function startTime()
•    - function totalReward()
•    - function earned(address account)
•    - function stake(uint256 amount)
•    - function withdraw(uint256 amount)
•    - function exit()
•    - function getReward()
•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function notifyReward()
•    - function setRewardDistribution(addres ...
•  contract LPTokenWrapper
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function stake(uint256 amount)
•    - function withdraw(uint256 amount)
•  contract LPPool is ILPPool, LPToke ... *
•    - function currentReward()
•    - function lastTimeRewardApplicable()
•    - function rewardPerToken()
•    - function earned(address account)
•    - function stake(uint256 amount)
•    - function withdraw(uint256 amount)
•    - function exit()
•    - function getReward()
•    - function notifyReward()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-12-07
*/

// File: @openzeppelin/contracts/math/Math.sol


pragma solidity ^0.7.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow, so we distribute
        return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
    }
}

// File: @openzeppelin/contracts/math/SafeMath.sol


pragma solidity ^0.7.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // 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;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        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;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


pragma solidity ^0.7.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

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

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

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

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

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

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


pragma solidity ^0.7.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) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }

    /**
     * @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");
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

// File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol


pragma solidity ^0.7.0;




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

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

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

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

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

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

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

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

// File: contracts/interfaces/ILPPool.sol


pragma solidity ^0.7.4;


interface ILPPool {
    //================== Callers ==================//
    function mir() external view returns (IERC20);

    function startTime() external view returns (uint256);

    function totalReward() external view returns (uint256);

    function earned(address account) external view returns (uint256);

    //================== Transactors ==================//

    function stake(uint256 amount) external;

    function withdraw(uint256 amount) external;

    function exit() external;

    function getReward() external;
}

// File: @openzeppelin/contracts/GSN/Context.sol


pragma solidity ^0.7.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 GSN 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 payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

// File: @openzeppelin/contracts/access/Ownable.sol


pragma solidity ^0.7.0;

/**
 * @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 () {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view 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 {
        emit OwnershipTransferred(_owner, address(0));
        _owner = 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");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// File: contracts/interfaces/IRewardDistributionRecipient.sol


pragma solidity ^0.7.4;


abstract contract IRewardDistributionRecipient is Ownable {
    address public rewardDistribution;

    function notifyReward() external virtual;

    modifier onlyRewardDistribution() {
        require(
            _msgSender() == rewardDistribution,
            'Caller is not reward distribution'
        );
        _;
    }

    function setRewardDistribution(address _rewardDistribution)
        external
        virtual
        onlyOwner
    {
        rewardDistribution = _rewardDistribution;
    }
}

// File: contracts/token/LPTokenWrapper.sol


pragma solidity ^0.7.4;




contract LPTokenWrapper {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    IERC20 public lpt;

    uint256 private _totalSupply;
    mapping(address => uint256) private _balances;

    function totalSupply() public view returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(address account) public view returns (uint256) {
        return _balances[account];
    }

    function stake(uint256 amount) public virtual {
        _totalSupply = _totalSupply.add(amount);
        _balances[msg.sender] = _balances[msg.sender].add(amount);
        lpt.safeTransferFrom(msg.sender, address(this), amount);
    }

    function withdraw(uint256 amount) public virtual {
        _totalSupply = _totalSupply.sub(amount);
        _balances[msg.sender] = _balances[msg.sender].sub(amount);
        lpt.safeTransfer(msg.sender, amount);
    }
}

// File: contracts/distribution/LPPool.sol


pragma solidity ^0.7.4;









contract LPPool is ILPPool, LPTokenWrapper, IRewardDistributionRecipient {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    uint256 public constant DURATION = 365 days;

    // Immutable
    IERC20 public immutable override mir;
    uint256 public immutable override startTime;
    uint256 public immutable override totalReward;

    // Time
    uint256 public periodFinish;
    uint256 public lastUpdateTime;

    // Reward
    uint256[] public rewards;
    uint256 public rewardRate;
    uint256 public rewardPerTokenStored;

    // Deflation
    uint256 public deflationCount = 0;

    mapping(address => uint256) public userRewardPerTokenPaid;
    mapping(address => uint256) public rewardEarned;

    // Events
    event RewardNotified(uint256 reward);
    event RewardUpdated(uint256 reward);
    event Staked(address indexed user, uint256 amount);
    event Withdrawn(address indexed user, uint256 amount);
    event RewardPaid(address indexed user, uint256 reward);

    constructor(
        address _mir,
        address _lpt,
        uint256 _startTime,
        uint256[] memory _rewards,
        uint256 _totalReward
    ) {
        require(
            _rewards.length > 0,
            "LPPool: initReward should be greater than zero"
        );
        require(
            _startTime > block.timestamp,
            "LPPool: startTime should be greater than current timestamp"
        );

        mir = IERC20(_mir);
        lpt = IERC20(_lpt);
        startTime = _startTime;
        rewards = _rewards;
        totalReward = _totalReward;
    }

    //================== Modifier ==================//

    modifier updateReward(address account) {
        rewardPerTokenStored = rewardPerToken();
        lastUpdateTime = lastTimeRewardApplicable();
        if (account != address(0)) {
            rewardEarned[account] = earned(account);
            userRewardPerTokenPaid[account] = rewardPerTokenStored;
        }
        _;
    }

    modifier checkHalve() {
        if (block.timestamp >= periodFinish && deflationCount < rewards.length.sub(1)) {
            deflationCount = deflationCount.add(1);
            rewardRate = currentReward().div(DURATION);
            periodFinish = block.timestamp.add(DURATION);
            emit RewardUpdated(currentReward());
        }
        _;
    }

    modifier checkStart() {
        require(block.timestamp >= startTime, "not start");
        _;
    }

    //================== Callers ==================//

    function currentReward() public view returns (uint256) {
        return rewards[deflationCount];
    }

    function lastTimeRewardApplicable() public view returns (uint256) {
        return Math.min(block.timestamp, periodFinish);
    }

    function rewardPerToken() public view returns (uint256) {
        if (totalSupply() == 0) {
            return rewardPerTokenStored;
        }
        return
            rewardPerTokenStored.add(
                lastTimeRewardApplicable()
                    .sub(lastUpdateTime)
                    .mul(rewardRate)
                    .mul(1e18)
                    .div(totalSupply())
            );
    }

    function earned(address account) public override view returns (uint256) {
        return
            balanceOf(account)
                .mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
                .div(1e18)
                .add(rewardEarned[account]);
    }

    //================== Transactors ==================//

    // stake visibility is public as overriding LPTokenWrapper's stake() function
    function stake(uint256 amount)
        public
        override(ILPPool, LPTokenWrapper)
        updateReward(msg.sender)
        checkHalve
        checkStart
    {
        require(amount > 0, "Cannot stake 0");
        super.stake(amount);
        emit Staked(msg.sender, amount);
    }

    function withdraw(uint256 amount)
        public
        override(ILPPool, LPTokenWrapper)
        updateReward(msg.sender)
        checkHalve
        checkStart
    {
        require(amount > 0, "Cannot withdraw 0");
        super.withdraw(amount);
        emit Withdrawn(msg.sender, amount);
    }

    function exit() external override {
        withdraw(balanceOf(msg.sender));
        getReward();
    }

    function getReward()
        public
        override
        updateReward(msg.sender)
        checkHalve
        checkStart
    {
        uint256 reward = earned(msg.sender);
        if (reward > 0) {
            rewardEarned[msg.sender] = 0;
            mir.safeTransfer(msg.sender, reward);
            emit RewardPaid(msg.sender, reward);
        }
    }

    function notifyReward()
        external
        override
        onlyRewardDistribution
        updateReward(address(0))
    {
        rewardRate = currentReward().div(DURATION);
        lastUpdateTime = startTime;
        periodFinish = startTime.add(DURATION);
        emit RewardNotified(currentReward());
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_mir","type":"address"},{"internalType":"address","name":"_lpt","type":"address"},{"internalType":"uint256","name":"_startTime","type":"uint256"},{"internalType":"uint256[]","name":"_rewards","type":"uint256[]"},{"internalType":"uint256","name":"_totalReward","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"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":"uint256","name":"reward","type":"uint256"}],"name":"RewardNotified","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Staked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdrawn","type":"event"},{"inputs":[],"name":"DURATION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deflationCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"earned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"exit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"lastTimeRewardApplicable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastUpdateTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lpt","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mir","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"notifyReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"periodFinish","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardDistribution","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"rewardEarned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerTokenStored","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"rewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_rewardDistribution","type":"address"}],"name":"setRewardDistribution","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","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":[{"internalType":"address","name":"","type":"address"}],"name":"userRewardPerTokenPaid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

0x608060405234801561001057600080fd5b50600436106101ce5760003560e01c806378e9792511610104578063c8f33c91116100a2578063e9fad8ee11610071578063e9fad8ee1461038b578063ebe2b12b14610393578063f2fde38b1461039b578063f301af42146103c1576101ce565b8063c8f33c911461036b578063cd3daf9d14610373578063ce5fc8d01461037b578063df136d6514610383576101ce565b80638b876347116100de5780638b876347146103185780638da5cb5b1461033e578063a694fc3a14610346578063a72bbad314610363576101ce565b806378e97925146103005780637b0a47ee1461030857806380faa57d14610310576101ce565b80631be05289116101715780635d54bda41161014b5780635d54bda4146102c257806370a08231146102ca578063715018a6146102f0578063750142e6146102f8576101ce565b80631be05289146102955780632e1a7d4d1461029d5780633d18b912146102ba576101ce565b80630d68b761116101ad5780630d68b76114610237578063101114cf1461025f57806316ba6bf31461026757806318160ddd1461028d576101ce565b80628cc262146101d357806307621eca1461020b5780630d1ae15114610213575b600080fd5b6101f9600480360360208110156101e957600080fd5b50356001600160a01b03166103de565b60408051918252519081900360200190f35b6101f961044c565b61021b61046e565b604080516001600160a01b039092168252519081900360200190f35b61025d6004803603602081101561024d57600080fd5b50356001600160a01b0316610492565b005b61021b61051e565b6101f96004803603602081101561027d57600080fd5b50356001600160a01b031661052d565b6101f961053f565b6101f9610545565b61025d600480360360208110156102b357600080fd5b503561054d565b61025d61072a565b61025d61090e565b6101f9600480360360208110156102e057600080fd5b50356001600160a01b0316610a4a565b61025d610a65565b6101f9610b19565b6101f9610b3d565b6101f9610b61565b6101f9610b67565b6101f96004803603602081101561032e57600080fd5b50356001600160a01b0316610b7a565b61021b610b8c565b61025d6004803603602081101561035c57600080fd5b5035610b9b565b6101f9610d75565b6101f9610d7b565b6101f9610d81565b61021b610dcf565b6101f9610dde565b61025d610de4565b6101f9610dff565b61025d600480360360208110156103b157600080fd5b50356001600160a01b0316610e05565b6101f9600480360360208110156103d757600080fd5b5035610f10565b6001600160a01b0381166000908152600c6020908152604080832054600b909252822054610446919061044090670de0b6b3a76400009061043a9061042b90610425610d81565b90610f31565b61043488610a4a565b90610f7a565b90610fd3565b90611015565b92915050565b60006007600a548154811061045d57fe5b906000526020600020015490505b90565b7f00000000000000000000000009a3ecafa817268f77be1283176b946c4ff2e60881565b61049a61106f565b6003546001600160a01b039081169116146104fc576040805162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015290519081900360640190fd5b600480546001600160a01b0319166001600160a01b0392909216919091179055565b6004546001600160a01b031681565b600c6020526000908152604090205481565b60015490565b6301e1338081565b33610556610d81565b600955610561610b67565b6006556001600160a01b038116156105a85761057c816103de565b6001600160a01b0382166000908152600c6020908152604080832093909355600954600b909152919020555b60055442101580156105c857506007546105c3906001610f31565b600a54105b1561063d57600a546105db906001611015565b600a556105ee6301e1338061043a61044c565b6008556105ff426301e13380611015565b6005557fcb94909754d27c309adf4167150f1f7aa04de40b6a0e6bb98b2ae80a2bf438f661062b61044c565b60408051918252519081900360200190a15b7f000000000000000000000000000000000000000000000000000000005fc935b042101561069e576040805162461bcd60e51b81526020600482015260096024820152681b9bdd081cdd185c9d60ba1b604482015290519081900360640190fd5b600082116106e7576040805162461bcd60e51b8152602060048201526011602482015270043616e6e6f74207769746864726177203607c1b604482015290519081900360640190fd5b6106f082611073565b60408051838152905133917f7084f5476618d8e60b11ef0d7d3f06914655adb8793e28ff7f018d4c76d505d5919081900360200190a25050565b33610733610d81565b60095561073e610b67565b6006556001600160a01b0381161561078557610759816103de565b6001600160a01b0382166000908152600c6020908152604080832093909355600954600b909152919020555b60055442101580156107a557506007546107a0906001610f31565b600a54105b1561081a57600a546107b8906001611015565b600a556107cb6301e1338061043a61044c565b6008556107dc426301e13380611015565b6005557fcb94909754d27c309adf4167150f1f7aa04de40b6a0e6bb98b2ae80a2bf438f661080861044c565b60408051918252519081900360200190a15b7f000000000000000000000000000000000000000000000000000000005fc935b042101561087b576040805162461bcd60e51b81526020600482015260096024820152681b9bdd081cdd185c9d60ba1b604482015290519081900360640190fd5b6000610886336103de565b9050801561090a57336000818152600c60205260408120556108d3907f00000000000000000000000009a3ecafa817268f77be1283176b946c4ff2e6086001600160a01b031690836110cb565b60408051828152905133917fe2403640ba68fed3a2f88b7557551d1993f84b99bb10ff833f0cf8db0c5e0486919081900360200190a25b5050565b6004546001600160a01b031661092261106f565b6001600160a01b0316146109675760405162461bcd60e51b81526004018080602001828103825260218152602001806115a06021913960400191505060405180910390fd5b6000610971610d81565b60095561097c610b67565b6006556001600160a01b038116156109c357610997816103de565b6001600160a01b0382166000908152600c6020908152604080832093909355600954600b909152919020555b6109d36301e1338061043a61044c565b6008557f000000000000000000000000000000000000000000000000000000005fc935b06006819055610a0a906301e13380611015565b6005557ff9a5da3a173eca8cd77c02ece3ff1467b8aa461ed3822201817f2d72fbc54283610a3661044c565b60408051918252519081900360200190a150565b6001600160a01b031660009081526002602052604090205490565b610a6d61106f565b6003546001600160a01b03908116911614610acf576040805162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015290519081900360640190fd5b6003546040516000916001600160a01b0316907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908390a3600380546001600160a01b0319169055565b7f00000000000000000000000000000000000000000005525dc7903887944bb13b81565b7f000000000000000000000000000000000000000000000000000000005fc935b081565b60085481565b6000610b7542600554611122565b905090565b600b6020526000908152604090205481565b6003546001600160a01b031690565b33610ba4610d81565b600955610baf610b67565b6006556001600160a01b03811615610bf657610bca816103de565b6001600160a01b0382166000908152600c6020908152604080832093909355600954600b909152919020555b6005544210158015610c165750600754610c11906001610f31565b600a54105b15610c8b57600a54610c29906001611015565b600a55610c3c6301e1338061043a61044c565b600855610c4d426301e13380611015565b6005557fcb94909754d27c309adf4167150f1f7aa04de40b6a0e6bb98b2ae80a2bf438f6610c7961044c565b60408051918252519081900360200190a15b7f000000000000000000000000000000000000000000000000000000005fc935b0421015610cec576040805162461bcd60e51b81526020600482015260096024820152681b9bdd081cdd185c9d60ba1b604482015290519081900360640190fd5b60008211610d32576040805162461bcd60e51b815260206004820152600e60248201526d043616e6e6f74207374616b6520360941b604482015290519081900360640190fd5b610d3b82611138565b60408051838152905133917f9e71bc8eea02a63969f509818f2dafb9254532904319f9dbda79b67bd34a5f3d919081900360200190a25050565b600a5481565b60065481565b6000610d8b61053f565b610d98575060095461046b565b610b75610dc6610da661053f565b61043a670de0b6b3a7640000610434600854610434600654610425610b67565b60095490611015565b6000546001600160a01b031681565b60095481565b610df5610df033610a4a565b61054d565b610dfd61072a565b565b60055481565b610e0d61106f565b6003546001600160a01b03908116911614610e6f576040805162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015290519081900360640190fd5b6001600160a01b038116610eb45760405162461bcd60e51b81526004018080602001828103825260268152602001806115596026913960400191505060405180910390fd5b6003546040516001600160a01b038084169216907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3600380546001600160a01b0319166001600160a01b0392909216919091179055565b60078181548110610f2057600080fd5b600091825260209091200154905081565b6000610f7383836040518060400160405280601e81526020017f536166654d6174683a207375627472616374696f6e206f766572666c6f77000081525061118e565b9392505050565b600082610f8957506000610446565b82820282848281610f9657fe5b0414610f735760405162461bcd60e51b815260040180806020018281038252602181526020018061157f6021913960400191505060405180910390fd5b6000610f7383836040518060400160405280601a81526020017f536166654d6174683a206469766973696f6e206279207a65726f000000000000815250611225565b600082820183811015610f73576040805162461bcd60e51b815260206004820152601b60248201527f536166654d6174683a206164646974696f6e206f766572666c6f770000000000604482015290519081900360640190fd5b3390565b6001546110809082610f31565b6001553360009081526002602052604090205461109d9082610f31565b3360008181526002602052604081209290925590546110c8916001600160a01b0390911690836110cb565b50565b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180516001600160e01b031663a9059cbb60e01b17905261111d90849061128a565b505050565b60008183106111315781610f73565b5090919050565b6001546111459082611015565b600155336000908152600260205260409020546111629082611015565b3360008181526002602052604081209290925590546110c8916001600160a01b0390911690308461133b565b6000818484111561121d5760405162461bcd60e51b81526004018080602001828103825283818151815260200191508051906020019080838360005b838110156111e25781810151838201526020016111ca565b50505050905090810190601f16801561120f5780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b505050900390565b600081836112745760405162461bcd60e51b81526020600482018181528351602484015283519092839260449091019190850190808383600083156111e25781810151838201526020016111ca565b50600083858161128057fe5b0495945050505050565b60606112df826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b031661139b9092919063ffffffff16565b80519091501561111d578080602001905160208110156112fe57600080fd5b505161111d5760405162461bcd60e51b815260040180806020018281038252602a8152602001806115c1602a913960400191505060405180910390fd5b604080516001600160a01b0380861660248301528416604482015260648082018490528251808303909101815260849091019091526020810180516001600160e01b03166323b872dd60e01b17905261139590859061128a565b50505050565b60606113aa84846000856113b2565b949350505050565b60606113bd8561151f565b61140e576040805162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604482015290519081900360640190fd5b60006060866001600160a01b031685876040518082805190602001908083835b6020831061144d5780518252601f19909201916020918201910161142e565b6001836020036101000a03801982511681845116808217855250505050505090500191505060006040518083038185875af1925050503d80600081146114af576040519150601f19603f3d011682016040523d82523d6000602084013e6114b4565b606091505b509150915081156114c85791506113aa9050565b8051156114d85780518082602001fd5b60405162461bcd60e51b81526020600482018181528651602484015286518793919283926044019190850190808383600083156111e25781810151838201526020016111ca565b6000813f7fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a4708181148015906113aa57505015159291505056fe4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061646472657373536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f7743616c6c6572206973206e6f742072657761726420646973747269627574696f6e5361666545524332303a204552433230206f7065726174696f6e20646964206e6f742073756363656564a2646970667358221220476878c705b315f1c4f51d5936c46194eb9ede33fce9083921e2531e54b5fd3764736f6c63430007040033

24616:5132:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27875:279;;;;;;;;;;;;;;;;-1:-1:-1;27875:279:0;-1:-1:-1;;;;;27875:279:0;;:::i;:::-;;;;;;;;;;;;;;;;27196:104;;;:::i;24834:36::-;;;:::i;:::-;;;;-1:-1:-1;;;;;24834:36:0;;;;;;;;;;;;;;23352:178;;;;;;;;;;;;;;;;-1:-1:-1;23352:178:0;-1:-1:-1;;;;;23352:178:0;;:::i;:::-;;23071:33;;;:::i;25312:47::-;;;;;;;;;;;;;;;;-1:-1:-1;25312:47:0;-1:-1:-1;;;;;25312:47:0;;:::i;23833:91::-;;;:::i;24764:43::-;;;:::i;28611:309::-;;;;;;;;;;;;;;;;-1:-1:-1;28611:309:0;;:::i;29042:370::-;;;:::i;29420:325::-;;;:::i;23932:110::-;;;;;;;;;;;;;;;;-1:-1:-1;23932:110:0;-1:-1:-1;;;;;23932:110:0;;:::i;22355:148::-;;;:::i;24927:45::-;;;:::i;24877:43::-;;;:::i;25112:25::-;;;:::i;27308:131::-;;;:::i;25248:57::-;;;;;;;;;;;;;;;;-1:-1:-1;25248:57:0;-1:-1:-1;;;;;25248:57:0;;:::i;21713:79::-;;;:::i;28306:297::-;;;;;;;;;;;;;;;;-1:-1:-1;28306:297:0;;:::i;25206:33::-;;;:::i;25028:29::-;;;:::i;27447:420::-;;;:::i;23718:17::-;;;:::i;25144:35::-;;;:::i;28928:106::-;;;:::i;24994:27::-;;;:::i;22658:244::-;;;;;;;;;;;;;;;;-1:-1:-1;22658:244:0;-1:-1:-1;;;;;22658:244:0;;:::i;25081:24::-;;;;;;;;;;;;;;;;-1:-1:-1;25081:24:0;;:::i;27875:279::-;-1:-1:-1;;;;;28124:21:0;;27938:7;28124:21;;;:12;:21;;;;;;;;;28040:22;:31;;;;;;27978:168;;28124:21;27978:123;;28096:4;;27978:95;;28019:53;;:16;:14;:16::i;:::-;:20;;:53::i;:::-;27978:18;27988:7;27978:9;:18::i;:::-;:40;;:95::i;:::-;:117;;:123::i;:::-;:145;;:168::i;:::-;27958:188;27875:279;-1:-1:-1;;27875:279:0:o;27196:104::-;27242:7;27269;27277:14;;27269:23;;;;;;;;;;;;;;;;27262:30;;27196:104;;:::o;24834:36::-;;;:::o;23352:178::-;21935:12;:10;:12::i;:::-;21925:6;;-1:-1:-1;;;;;21925:6:0;;;:22;;;21917:67;;;;;-1:-1:-1;;;21917:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23482:18:::1;:40:::0;;-1:-1:-1;;;;;;23482:40:0::1;-1:-1:-1::0;;;;;23482:40:0;;;::::1;::::0;;;::::1;::::0;;23352:178::o;23071:33::-;;;-1:-1:-1;;;;;23071:33:0;;:::o;25312:47::-;;;;;;;;;;;;;:::o;23833:91::-;23904:12;;23833:91;:::o;24764:43::-;24799:8;24764:43;:::o;28611:309::-;28726:10;26388:16;:14;:16::i;:::-;26365:20;:39;26432:26;:24;:26::i;:::-;26415:14;:43;-1:-1:-1;;;;;26473:21:0;;;26469:162;;26535:15;26542:7;26535:6;:15::i;:::-;-1:-1:-1;;;;;26511:21:0;;;;;;:12;:21;;;;;;;;:39;;;;26599:20;;26565:22;:31;;;;;;:54;26469:162;26714:12:::1;;26695:15;:31;;:73;;;;-1:-1:-1::0;26747:7:0::1;:14:::0;:21:::1;::::0;26766:1:::1;26747:18;:21::i;:::-;26730:14;;:38;26695:73;26691:310;;;26802:14;::::0;:21:::1;::::0;26821:1:::1;26802:18;:21::i;:::-;26785:14;:38:::0;26851:29:::1;24799:8;26851:15;:13;:15::i;:29::-;26838:10;:42:::0;26910:29:::1;:15;24799:8;26910:19;:29::i;:::-;26895:12;:44:::0;26959:30:::1;26973:15;:13;:15::i;:::-;26959:30;::::0;;;;;;;;;;::::1;::::0;;::::1;26691:310;27088:9:::2;27069:15;:28;;27061:50;;;::::0;;-1:-1:-1;;;27061:50:0;;::::2;;::::0;::::2;::::0;::::2;::::0;;;;-1:-1:-1;;;27061:50:0;;;;;;;;;;;;;::::2;;28811:1:::3;28802:6;:10;28794:40;;;::::0;;-1:-1:-1;;;28794:40:0;;::::3;;::::0;::::3;::::0;::::3;::::0;;;;-1:-1:-1;;;28794:40:0;;;;;;;;;;;;;::::3;;28845:22;28860:6;28845:14;:22::i;:::-;28883:29;::::0;;;;;;;28893:10:::3;::::0;28883:29:::3;::::0;;;;;::::3;::::0;;::::3;28611:309:::0;;:::o;29042:370::-;29119:10;26388:16;:14;:16::i;:::-;26365:20;:39;26432:26;:24;:26::i;:::-;26415:14;:43;-1:-1:-1;;;;;26473:21:0;;;26469:162;;26535:15;26542:7;26535:6;:15::i;:::-;-1:-1:-1;;;;;26511:21:0;;;;;;:12;:21;;;;;;;;:39;;;;26599:20;;26565:22;:31;;;;;;:54;26469:162;26714:12:::1;;26695:15;:31;;:73;;;;-1:-1:-1::0;26747:7:0::1;:14:::0;:21:::1;::::0;26766:1:::1;26747:18;:21::i;:::-;26730:14;;:38;26695:73;26691:310;;;26802:14;::::0;:21:::1;::::0;26821:1:::1;26802:18;:21::i;:::-;26785:14;:38:::0;26851:29:::1;24799:8;26851:15;:13;:15::i;:29::-;26838:10;:42:::0;26910:29:::1;:15;24799:8;26910:19;:29::i;:::-;26895:12;:44:::0;26959:30:::1;26973:15;:13;:15::i;:::-;26959:30;::::0;;;;;;;;;;::::1;::::0;;::::1;26691:310;27088:9:::2;27069:15;:28;;27061:50;;;::::0;;-1:-1:-1;;;27061:50:0;;::::2;;::::0;::::2;::::0;::::2;::::0;;;;-1:-1:-1;;;27061:50:0;;;;;;;;;;;;;::::2;;29187:14:::3;29204:18;29211:10;29204:6;:18::i;:::-;29187:35:::0;-1:-1:-1;29237:10:0;;29233:172:::3;;29277:10;29291:1;29264:24:::0;;;:12:::3;:24;::::0;;;;:28;29307:36:::3;::::0;:3:::3;-1:-1:-1::0;;;;;29307:16:0::3;::::0;29336:6;29307:16:::3;:36::i;:::-;29363:30;::::0;;;;;;;29374:10:::3;::::0;29363:30:::3;::::0;;;;;::::3;::::0;;::::3;29233:172;27122:1;29042:370:::0;:::o;29420:325::-;23245:18;;-1:-1:-1;;;;;23245:18:0;23229:12;:10;:12::i;:::-;-1:-1:-1;;;;;23229:34:0;;23207:117;;;;-1:-1:-1;;;23207:117:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29542:1:::1;26388:16;:14;:16::i;:::-;26365:20;:39:::0;26432:26:::1;:24;:26::i;:::-;26415:14;:43:::0;-1:-1:-1;;;;;26473:21:0;::::1;::::0;26469:162:::1;;26535:15;26542:7;26535:6;:15::i;:::-;-1:-1:-1::0;;;;;26511:21:0;::::1;;::::0;;;:12:::1;:21;::::0;;;;;;;:39;;;;26599:20:::1;::::0;26565:22:::1;:31:::0;;;;;;:54;26469:162:::1;29575:29:::2;24799:8;29575:15;:13;:15::i;:29::-;29562:10;:42:::0;29632:9:::2;29615:14;:26:::0;;;29667:23:::2;::::0;24799:8:::2;29667:13;:23::i;:::-;29652:12;:38:::0;29706:31:::2;29721:15;:13;:15::i;:::-;29706:31;::::0;;;;;;;;;;::::2;::::0;;::::2;23335:1:::1;29420:325::o:0;23932:110::-;-1:-1:-1;;;;;24016:18:0;23989:7;24016:18;;;:9;:18;;;;;;;23932:110::o;22355:148::-;21935:12;:10;:12::i;:::-;21925:6;;-1:-1:-1;;;;;21925:6:0;;;:22;;;21917:67;;;;;-1:-1:-1;;;21917:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22446:6:::1;::::0;22425:40:::1;::::0;22462:1:::1;::::0;-1:-1:-1;;;;;22446:6:0::1;::::0;22425:40:::1;::::0;22462:1;;22425:40:::1;22476:6;:19:::0;;-1:-1:-1;;;;;;22476:19:0::1;::::0;;22355:148::o;24927:45::-;;;:::o;24877:43::-;;;:::o;25112:25::-;;;;:::o;27308:131::-;27365:7;27392:39;27401:15;27418:12;;27392:8;:39::i;:::-;27385:46;;27308:131;:::o;25248:57::-;;;;;;;;;;;;;:::o;21713:79::-;21778:6;;-1:-1:-1;;;;;21778:6:0;21713:79;:::o;28306:297::-;28418:10;26388:16;:14;:16::i;:::-;26365:20;:39;26432:26;:24;:26::i;:::-;26415:14;:43;-1:-1:-1;;;;;26473:21:0;;;26469:162;;26535:15;26542:7;26535:6;:15::i;:::-;-1:-1:-1;;;;;26511:21:0;;;;;;:12;:21;;;;;;;;:39;;;;26599:20;;26565:22;:31;;;;;;:54;26469:162;26714:12:::1;;26695:15;:31;;:73;;;;-1:-1:-1::0;26747:7:0::1;:14:::0;:21:::1;::::0;26766:1:::1;26747:18;:21::i;:::-;26730:14;;:38;26695:73;26691:310;;;26802:14;::::0;:21:::1;::::0;26821:1:::1;26802:18;:21::i;:::-;26785:14;:38:::0;26851:29:::1;24799:8;26851:15;:13;:15::i;:29::-;26838:10;:42:::0;26910:29:::1;:15;24799:8;26910:19;:29::i;:::-;26895:12;:44:::0;26959:30:::1;26973:15;:13;:15::i;:::-;26959:30;::::0;;;;;;;;;;::::1;::::0;;::::1;26691:310;27088:9:::2;27069:15;:28;;27061:50;;;::::0;;-1:-1:-1;;;27061:50:0;;::::2;;::::0;::::2;::::0;::::2;::::0;;;;-1:-1:-1;;;27061:50:0;;;;;;;;;;;;;::::2;;28503:1:::3;28494:6;:10;28486:37;;;::::0;;-1:-1:-1;;;28486:37:0;;::::3;;::::0;::::3;::::0;::::3;::::0;;;;-1:-1:-1;;;28486:37:0;;;;;;;;;;;;;::::3;;28534:19;28546:6;28534:11;:19::i;:::-;28569:26;::::0;;;;;;;28576:10:::3;::::0;28569:26:::3;::::0;;;;;::::3;::::0;;::::3;28306:297:::0;;:::o;25206:33::-;;;;:::o;25028:29::-;;;;:::o;27447:420::-;27494:7;27518:13;:11;:13::i;:::-;27514:78;;-1:-1:-1;27560:20:0;;27553:27;;27514:78;27622:237;27665:179;27830:13;:11;:13::i;:::-;27665:138;27798:4;27665:106;27760:10;;27665:68;27718:14;;27665:26;:24;:26::i;:179::-;27622:20;;;:24;:237::i;23718:17::-;;;-1:-1:-1;;;;;23718:17:0;;:::o;25144:35::-;;;;:::o;28928:106::-;28973:31;28982:21;28992:10;28982:9;:21::i;:::-;28973:8;:31::i;:::-;29015:11;:9;:11::i;:::-;28928:106::o;24994:27::-;;;;:::o;22658:244::-;21935:12;:10;:12::i;:::-;21925:6;;-1:-1:-1;;;;;21925:6:0;;;:22;;;21917:67;;;;;-1:-1:-1;;;21917:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;22747:22:0;::::1;22739:73;;;;-1:-1:-1::0;;;22739:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22849:6;::::0;22828:38:::1;::::0;-1:-1:-1;;;;;22828:38:0;;::::1;::::0;22849:6:::1;::::0;22828:38:::1;::::0;22849:6:::1;::::0;22828:38:::1;22877:6;:17:::0;;-1:-1:-1;;;;;;22877:17:0::1;-1:-1:-1::0;;;;;22877:17:0;;;::::1;::::0;;;::::1;::::0;;22658:244::o;25081:24::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;25081:24:0;:::o;2238:136::-;2296:7;2323:43;2327:1;2330;2323:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;2316:50;2238:136;-1:-1:-1;;;2238:136:0:o;3128:471::-;3186:7;3431:6;3427:47;;-1:-1:-1;3461:1:0;3454:8;;3427:47;3498:5;;;3502:1;3498;:5;:1;3522:5;;;;;:10;3514:56;;;;-1:-1:-1;;;3514:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4075:132;4133:7;4160:39;4164:1;4167;4160:39;;;;;;;;;;;;;;;;;:3;:39::i;1774:181::-;1832:7;1864:5;;;1888:6;;;;1880:46;;;;;-1:-1:-1;;;1880:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;20267:106;20355:10;20267:106;:::o;24296:222::-;24371:12;;:24;;24388:6;24371:16;:24::i;:::-;24356:12;:39;24440:10;24430:21;;;;:9;:21;;;;;;:33;;24456:6;24430:25;:33::i;:::-;24416:10;24406:21;;;;:9;:21;;;;;:57;;;;24474:3;;:36;;-1:-1:-1;;;;;24474:3:0;;;;24503:6;24474:16;:36::i;:::-;24296:222;:::o;15933:177::-;16043:58;;;-1:-1:-1;;;;;16043:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;16043:58:0;-1:-1:-1;;;16043:58:0;;;16016:86;;16036:5;;16016:19;:86::i;:::-;15933:177;;;:::o;426:106::-;484:7;515:1;511;:5;:13;;523:1;511:13;;;-1:-1:-1;519:1:0;;426:106;-1:-1:-1;426:106:0:o;24050:238::-;24122:12;;:24;;24139:6;24122:16;:24::i;:::-;24107:12;:39;24191:10;24181:21;;;;:9;:21;;;;;;:33;;24207:6;24181:25;:33::i;:::-;24167:10;24157:21;;;;:9;:21;;;;;:57;;;;24225:3;;:55;;-1:-1:-1;;;;;24225:3:0;;;;24266:4;24273:6;24225:20;:55::i;2677:192::-;2763:7;2799:12;2791:6;;;;2783:29;;;;-1:-1:-1;;;2783:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;2835:5:0;;;2677:192::o;4703:278::-;4789:7;4824:12;4817:5;4809:28;;;;-1:-1:-1;;;4809:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4848:9;4864:1;4860;:5;;;;;;;4703:278;-1:-1:-1;;;;;4703:278:0:o;18238:761::-;18662:23;18688:69;18716:4;18688:69;;;;;;;;;;;;;;;;;18696:5;-1:-1:-1;;;;;18688:27:0;;;:69;;;;;:::i;:::-;18772:17;;18662:95;;-1:-1:-1;18772:21:0;18768:224;;18914:10;18903:30;;;;;;;;;;;;;;;-1:-1:-1;18903:30:0;18895:85;;;;-1:-1:-1;;;18895:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16118:205;16246:68;;;-1:-1:-1;;;;;16246:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;16246:68:0;-1:-1:-1;;;16246:68:0;;;16219:96;;16239:5;;16219:19;:96::i;:::-;16118:205;;;;:::o;12914:196::-;13017:12;13049:53;13072:6;13080:4;13086:1;13089:12;13049:22;:53::i;:::-;13042:60;12914:196;-1:-1:-1;;;;12914:196:0:o;14291:979::-;14421:12;14454:18;14465:6;14454:10;:18::i;:::-;14446:60;;;;;-1:-1:-1;;;14446:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;14580:12;14594:23;14621:6;-1:-1:-1;;;;;14621:11:0;14641:8;14652:4;14621:36;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;14621:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14579:78;;;;14672:7;14668:595;;;14703:10;-1:-1:-1;14696:17:0;;-1:-1:-1;14696:17:0;14668:595;14817:17;;:21;14813:439;;15080:10;15074:17;15141:15;15128:10;15124:2;15120:19;15113:44;15028:148;15216:20;;-1:-1:-1;;;15216:20:0;;;;;;;;;;;;;;;;;15223:12;;15216:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9799:619;9859:4;10327:20;;10170:66;10367:23;;;;;;:42;;-1:-1:-1;;10394:15:0;;;10359:51;-1:-1:-1;;9799:619:0:o

ipfs://476878c705b315f1c4f51d5936c46194eb9ede33fce9083921e2531e54b5fd37