Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC165
•    - function supportsInterface(bytes4 int ...
• interface IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function safeTransferFrom(
•    - function safeTransferFrom(
•    - function transferFrom(
•    - function approve(address to, uint256 ...
•    - function setApprovalForAll(address op ...
•    - function getApproved(uint256 tokenId)
•    - function isApprovedForAll(address own ...
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(
•    - function verifyCallResult(
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• library SafeERC20
•    - function safeTransfer(
•    - function safeTransferFrom(
•    - function safeApprove(
•    - function safeIncreaseAllowance(
•    - function safeDecreaseAllowance(
•    - function _callOptionalReturn(IERC20 t ...
• interface IERC4626 is IERC20
•    - function asset()
•    - function totalAssets()
•    - function convertToShares(uint256 asse ...
•    - function convertToAssets(uint256 shar ...
•    - function maxDeposit(address receiver)
•    - function previewDeposit(uint256 asset ...
•    - function deposit(uint256 assets, addr ...
•    - function maxMint(address receiver)
•    - function previewMint(uint256 shares)
•    - function mint(uint256 shares, address ...
•    - function maxWithdraw(address owner)
•    - function previewWithdraw(uint256 asse ...
•    - function withdraw(uint256 assets, add ...
•    - function maxRedeem(address owner)
•    - function previewRedeem(uint256 shares ...
•    - function redeem(uint256 shares, addre ...
• interface IVeVault is IERC4626
•    - function asset()
•    - function totalAssets()
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function convertToShares(uint256 asse ...
•    - function convertToShares(uint256 asse ...
•    - function convertToAssets(uint256 shar ...
•    - function convertToAssets(uint256 shar ...
•    - function maxDeposit(address)
•    - function previewDeposit(uint256 asset ...
•    - function previewDeposit(uint256 asset ...
•    - function maxMint(address)
•    - function previewMint(uint256 shares, ...
•    - function previewMint(uint256 shares)
•    - function maxWithdraw(address owner)
•    - function previewWithdraw(uint256 asse ...
•    - function previewWithdraw(uint256 asse ...
•    - function maxRedeem(address owner)
•    - function previewRedeem(uint256 shares ...
•    - function previewRedeem(uint256 shares ...
•    - function allowance(address, address)
•    - function assetBalanceOf(address accou ...
•    - function unlockDate(address account)
•    - function gracePeriod()
•    - function penaltyPercentage()
•    - function minLockTime()
•    - function maxLockTime()
•    - function transfer(address, uint256)
•    - function approve(address, uint256)
•    - function transferFrom(address, addres ...
•    - function veMult(address owner)
•    - function deposit(uint256 assets, addr ...
•    - function deposit(uint256 assets, addr ...
•    - function mint(uint256 shares, address ...
•    - function mint(uint256 shares, address ...
•    - function withdraw(uint256 assets, add ...
•    - function redeem(uint256 shares, addre ...
•    - function exit()
•    - function changeUnlockRule(bool flag)
•    - function changeGracePeriod(uint256 ne ...
•    - function changeEpoch(uint256 newEpoch ...
•    - function changeMinPenalty(uint256 new ...
•    - function changeMaxPenalty(uint256 new ...
•    - function changeWhitelistRecoverERC20( ...
•    - function recoverERC20(address tokenAd ...
•    - function recoverERC721(address tokenA ...
•    - function nominateNewOwner(address _ow ...
•    - function acceptOwnership()
•    - function _onlyOwner()
•    - function setPaused(bool _paused)
•    - function notifyRewardAmount(uint256 r ...
•    - function setRewardsDistribution(addre ...
•  contract Rewards is RewardsDistrib ... *
•    - function getVaultAddress()
•    - function lastTimeRewardApplicable(add ...
•    - function rewardPerToken(address owner ...
•    - function earned(address owner)
•    - function getRewardForDuration()
•    - function notifyDeposit()
•    - function getReward()
•    - function notifyRewardAmount(uint256 r ...
•    - function setRewardsDuration(uint256 _ ...
•    - function recoverERC20(address tokenAd ...
•    - function changeWhitelistRecoverERC20( ...
•    - function recoverERC721(address tokenA ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-06-17
*/

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol


// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

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

// File: @openzeppelin/contracts/token/ERC721/IERC721.sol


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;


/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

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

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

        _;

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

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


// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

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

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

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

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

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

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

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

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

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

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

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

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

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

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

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


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

// File: @openzeppelin/contracts/interfaces/IERC20.sol


// OpenZeppelin Contracts v4.4.1 (interfaces/IERC20.sol)

pragma solidity ^0.8.0;


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


// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.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 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");
        }
    }
}

// File: contracts/veRewards.sol


pragma solidity ^0.8.13;





interface IERC4626 is IERC20 {
    // The address of the underlying token used for the Vault for accounting, depositing, and withdrawing.
    function asset() external view returns(address assetTokenAddress);

    // Total amount of the underlying asset that is “managed” by Vault.
    function totalAssets() external view returns(uint256 totalManagedAssets);

    // The amount of shares that the Vault would exchange for the amount of assets provided, in an ideal scenario where all the conditions are met.
    function convertToShares(uint256 assets) external view returns(uint256 shares); 

    // The amount of assets that the Vault would exchange for the amount of shares provided, in an ideal scenario where all the conditions are met.
    function convertToAssets(uint256 shares) external view returns(uint256 assets);
 
    // Maximum amount of the underlying asset that can be deposited into the Vault for the receiver, through a deposit call.
    function maxDeposit(address receiver) external view returns(uint256 maxAssets);

    // Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given current on-chain conditions.
    function previewDeposit(uint256 assets) external view returns(uint256 shares);

    // Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.
    function deposit(uint256 assets, address receiver) external returns(uint256 shares);

    // Maximum amount of shares that can be minted from the Vault for the receiver, through a mint call.
    function maxMint(address receiver) external view returns(uint256 maxShares); 

    // Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given current on-chain conditions.
    function previewMint(uint256 shares) external view returns(uint256 assets);

    // Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.
    function mint(uint256 shares, address receiver) external returns(uint256 assets);

    // Maximum amount of the underlying asset that can be withdrawn from the owner balance in the Vault, through a withdraw call.
    function maxWithdraw(address owner) external view returns(uint256 maxAssets);

    // Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block, given current on-chain conditions.
    function previewWithdraw(uint256 assets) external view returns(uint256 shares);

    // Burns shares from owner and sends exactly assets of underlying tokens to receiver.
    function withdraw(uint256 assets, address receiver, address owner) external returns(uint256 shares);

    // Maximum amount of Vault shares that can be redeemed from the owner balance in the Vault, through a redeem call.
    function maxRedeem(address owner) external view returns(uint256 maxShares);

    // Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block, given current on-chain conditions.
    function previewRedeem(uint256 shares) external view returns(uint256 assets);

    // Burns exactly shares from owner and sends assets of underlying tokens to receiver.
    function redeem(uint256 shares, address receiver, address owner) external returns(uint256 assets);

    event Deposit(address indexed caller, address indexed owner, uint256 assets, uint256 shares);
    event Withdraw(address indexed caller, address indexed receiver, address indexed owner, uint256 assets, uint256 shares);
}

interface IVeVault is IERC4626 {
    function asset() external view  returns (address assetTokenAddress);
    function totalAssets() external view  returns (uint256 totalManagedAssets);
    function totalSupply() external view  returns (uint256);
    function balanceOf(address account) external view  returns (uint256);
    function convertToShares(uint256 assets, uint256 lockTime) external view returns (uint256 shares);
    function convertToShares(uint256 assets)  external view returns (uint256 shares);
    function convertToAssets(uint256 shares, uint256 lockTime) external view returns (uint256 assets);
    function convertToAssets(uint256 shares)  external view returns (uint256 assets);
    function maxDeposit(address)  external pure returns (uint256 maxAssets);
    function previewDeposit(uint256 assets, uint256 lockTime) external view returns (uint256 shares);
    function previewDeposit(uint256 assets)  external view returns (uint256 shares);
    function maxMint(address)  external pure returns (uint256 maxShares);
    function previewMint(uint256 shares, uint256 lockTime) external view returns (uint256 assets);
    function previewMint(uint256 shares)  external view returns (uint256 assets);
    function maxWithdraw(address owner)  external view returns (uint256 maxAssets);
    function previewWithdraw(uint256 assets, uint256 lockTime) external view returns (uint256 shares);
    function previewWithdraw(uint256 assets)  external view returns (uint256 shares);
    function maxRedeem(address owner)  external view returns (uint256 maxShares);
    function previewRedeem(uint256 shares, uint256 lockTime) external view returns (uint256 assets);
    function previewRedeem(uint256 shares)  external view returns (uint256 assets);
    function allowance(address, address)  external view returns (uint256);
    function assetBalanceOf(address account) external view returns (uint256);
    function unlockDate(address account) external view returns (uint256);
    function gracePeriod() external view returns (uint256);
    function penaltyPercentage() external view returns (uint256);
    function minLockTime() external view returns (uint256);
    function maxLockTime() external view returns (uint256);
    function transfer(address, uint256) external  returns (bool);
    function approve(address, uint256) external  returns (bool);
    function transferFrom(address, address, uint256) external  returns (bool);
    function veMult(address owner) external view returns (uint256);
    function deposit(uint256 assets, address receiver, uint256 lockTime) external returns (uint256 shares);
    function deposit(uint256 assets, address receiver)  external returns (uint256 shares);
    function mint(uint256 shares, address receiver, uint256 lockTime) external returns (uint256 assets);
    function mint(uint256 shares, address receiver)  external returns (uint256 assets);
    function withdraw(uint256 assets, address receiver, address owner)  external returns (uint256 shares);
    function redeem(uint256 shares, address receiver, address owner)  external returns (uint256 assets);
    function exit() external returns (uint256 shares);
    function changeUnlockRule(bool flag) external;
    function changeGracePeriod(uint256 newGracePeriod) external;
    function changeEpoch(uint256 newEpoch) external;
    function changeMinPenalty(uint256 newMinPenalty) external;
    function changeMaxPenalty(uint256 newMaxPenalty) external;
    function changeWhitelistRecoverERC20(address tokenAddress, bool flag) external;
    function recoverERC20(address tokenAddress, uint256 tokenAmount) external;
    function recoverERC721(address tokenAddress, uint256 tokenId) external;

    event PayPenalty(address indexed caller, address indexed owner, uint256 assets);
    event Burn(address indexed user, uint256 shares);
    event Mint(address indexed user, uint256 shares);
    event Recovered(address token, uint256 amount);
    event RecoveredNFT(address tokenAddress, uint256 tokenId);
    event ChangeWhitelistERC20(address indexed tokenAddress, bool whitelistState);
}

// https://docs.synthetix.io/contracts/source/contracts/Owned
abstract contract Owned {
    address public owner;
    address public nominatedOwner;

    constructor(address _owner) {
        require(_owner != address(0), "Owner address cannot be 0");
        owner = _owner;
        emit OwnerChanged(address(0), _owner);
    }

    function nominateNewOwner(address _owner) external onlyOwner {
        nominatedOwner = _owner;
        emit OwnerNominated(_owner);
    }

    function acceptOwnership() external {
        require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
        emit OwnerChanged(owner, nominatedOwner);
        owner = nominatedOwner;
        nominatedOwner = address(0);
    }

    modifier onlyOwner {
        _onlyOwner();
        _;
    }

    function _onlyOwner() private view {
        require(msg.sender == owner, "Only the contract owner may perform this action");
    }

    event OwnerNominated(address newOwner);
    event OwnerChanged(address oldOwner, address newOwner);
}

// https://docs.synthetix.io/contracts/source/contracts/Pausable
abstract contract Pausable is Owned {
    uint public lastPauseTime;
    bool public paused;

    constructor() {
        // This contract is abstract, and thus cannot be instantiated directly
        require(owner != address(0), "Owner must be set");
        // Paused will be false, and lastPauseTime will be 0 upon initialisation
    }

    /**
     * @notice Change the paused state of the contract
     * @dev Only the contract owner may call this.
     */
    function setPaused(bool _paused) external onlyOwner {
        // Ensure we're actually changing the state before we do anything
        if (_paused == paused) {
            return;
        }

        // Set our paused state.
        paused = _paused;

        // If applicable, set the last pause time.
        if (paused) {
            lastPauseTime = block.timestamp;
        }

        // Let everyone know that our pause state has changed.
        emit PauseChanged(paused);
    }

    event PauseChanged(bool isPaused);

    modifier notPaused {
        require(!paused, "This action cannot be performed while the contract is paused");
        _;
    }
}

// https://docs.synthetix.io/contracts/source/contracts/RewardsDistributionRecipient
abstract contract RewardsDistributionRecipient is Owned {
    address public rewardsDistribution;

    function notifyRewardAmount(uint256 reward) virtual external;

    modifier onlyRewardsDistribution() {
        require(msg.sender == rewardsDistribution, "Caller is not RewardsDistribution contract");
        _;
    }

    function setRewardsDistribution(address _rewardsDistribution) external onlyOwner {
        rewardsDistribution = _rewardsDistribution;
    }
}

error RewardTooHigh();
error RewardPeriodNotComplete(uint256 finish);
error NotWhitelisted();
error InsufficientBalance(uint256 available, uint256 required);

/** 
 * @title Implements a reward system which grant rewards based on veToken balance 
 * @author gcontarini jocorrei
 * @notice This implementation was inspired by the StakingReward contract from Synthetixio
 * @dev Implement a new constructor to deploy this contract 
 */
contract Rewards is RewardsDistributionRecipient, ReentrancyGuard, Pausable {
    using SafeERC20 for IERC20;

    struct Account {
        uint256 rewardPerTokenPaid;
        uint256 rewards;
        uint256 dueDate;
    }

    /* ========== STATE VARIABLES ========== */

    address public rewardsToken;
    address public vault;                    // address of the ve vault
    uint256 public periodFinish = 0;         // end of the rewardDuration period
    uint256 public rewardRate = 0;           // rewards per second distributed by the contract ==> rewardavailable / rewardDuration
    uint256 public rewardsDuration = 7 days; // the rewards inside the contract are gone be distributed during this period
    uint256 public lastUpdateTime;           // when the reward period started
    uint256 public rewardPerTokenStored;     // amounts of reward per staked token

    mapping(address => Account) public accounts;
    
    // Only allow recoverERC20 from this list
    mapping(address => bool) public whitelistRecoverERC20;

    /* ========== CONSTRUCTOR ========== */

    constructor(
        address _owner,
        address _vault,
        address _rewardsDistribution,
        address _rewardsToken
    ) Owned(_owner) {
        rewardsToken = _rewardsToken;
        rewardsDistribution = _rewardsDistribution;
        vault = _vault;
        lastUpdateTime = block.timestamp;
    }

    /* ========== VIEWS ========== */

    /**
     * @notice Get the vault address
     */
    function getVaultAddress() public view returns (address) {
        return vault;
    }

    /**
     * @notice Pick the correct date for applying the reward
     * Apply until the end of periodFinish or until
     * unlockDate for funds in the veVault
     * @return date which the reward is applicable for and address
     */
    function lastTimeRewardApplicable(address owner) public view returns (uint256) {
        if (owner != address(0) && accounts[owner].dueDate < periodFinish) {
            return block.timestamp < accounts[owner].dueDate ? block.timestamp : accounts[owner].dueDate;
        }
        return block.timestamp < periodFinish ? block.timestamp : periodFinish;
    }

    /**
     * @notice Calculate how much reward must be given for an user
     * per token in veVault. 
     * @dev If dueDate is less than the period finish,
     * a "negative" reward is applied to ensure that
     * rewards are applied only until this date.
     * @return amount of reward per token an addres is elegible to receive so far
     */
    function rewardPerToken(address owner) public view returns (uint256) {
        uint256 _totalSupply = IVeVault(vault).totalSupply();

        if (_totalSupply == 0) {
            return rewardPerTokenStored;
        }
        uint256 userLastTime = lastTimeRewardApplicable(owner);
        
        // Apply a negative reward per token when
        // due date is already over.
        if (userLastTime < lastUpdateTime) {
            return rewardPerTokenStored
                - ((lastUpdateTime - userLastTime)
                    * rewardRate
                    * 1e18
                    / _totalSupply
                );
        }
        return rewardPerTokenStored
                + ((userLastTime - lastUpdateTime)
                    * rewardRate
                    * 1e18
                    / _totalSupply
                );
    }
    
    /**
     * @notice Calculates how much rewards a staker earned 
     * until this moment.
     * @dev Only apply reward until period finish or unlock date.
     * @return amount of reward available to claim 
     */
    function earned(address owner) public view returns (uint256) {
        uint256 currentReward = rewardPerToken(owner);
        uint256 paidReward = accounts[owner].rewardPerTokenPaid;

        uint256 moreReward = 0;
        if (currentReward > paidReward) {
            moreReward = IVeVault(vault).balanceOf(owner)
                            * (currentReward - paidReward)
                            / 1e18;
        }
        return accounts[owner].rewards + moreReward;
    }

    /**
     * @notice Total rewards that will be paid during the distribution
     */
    function getRewardForDuration() external view returns (uint256) {
        return rewardRate * rewardsDuration;
    }

    /* ========== MUTATIVE FUNCTIONS ========== */

    /**
     * @notice Notify the reward contract about a deposit in the
     * veVault contract. This is important to assure the
     * contract will account user's rewards.
     * @return account full information
     */
    function notifyDeposit() public updateReward(msg.sender) returns(Account memory) {
        emit NotifyDeposit(msg.sender, accounts[owner].rewardPerTokenPaid, accounts[owner].dueDate);
        return accounts[owner];
    }

    /**
     * @notice Claim rewards for user.
     * @dev In case of no rewards claimable
     * just update the user status and do nothing.
     */
    function getReward() public updateReward(msg.sender) {
        uint256 reward = accounts[msg.sender].rewards;
        if (reward <= 0) return;
        
        accounts[msg.sender].rewards = 0;
        IERC20(rewardsToken).safeTransfer(msg.sender, reward);
        emit RewardPaid(msg.sender, reward);
    }

    /* ========== RESTRICTED FUNCTIONS ========== */

    /**
     * @notice Set the contract to start distribuiting rewards
     * for ve holders.
     * @param reward: amount of tokens to be distributed
     */
    function notifyRewardAmount(uint256 reward)
            external
            override 
            onlyRewardsDistribution 
            updateReward(address(0)) {
        if (block.timestamp >= periodFinish) {
            rewardRate = reward / rewardsDuration;
        } else {
            uint256 remaining = periodFinish - block.timestamp;
            uint256 leftover = remaining * rewardRate;
            rewardRate = (reward + leftover) / rewardsDuration;
        }

        // Ensure the provided reward amount is not more than the balance in the contract.
        // This keeps the reward rate in the right range, preventing overflows due to
        // very high values of rewardRate in the earned and rewardsPerToken functions;
        // Reward + leftover must be less than 2^256 / 10^18 to avoid overflow.
        uint balance = IERC20(rewardsToken).balanceOf(address(this));
        if (rewardRate > balance / rewardsDuration) revert RewardTooHigh();

        lastUpdateTime = block.timestamp;
        periodFinish = block.timestamp + rewardsDuration;
        emit RewardAdded(reward);
    }
    
    /**
     * @notice Allow owner to change reward duration
     * Only allow the change if period finish has already ended
     */
    function setRewardsDuration(uint256 _rewardsDuration) external onlyOwner {
        if (block.timestamp <= periodFinish) revert RewardPeriodNotComplete(periodFinish);

        rewardsDuration = _rewardsDuration;
        emit RewardsDurationUpdated(rewardsDuration);
    }

    /**
     * @notice Added to support to recover ERC20 token within a whitelist 
     */
    function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
        if (whitelistRecoverERC20[tokenAddress] == false) revert NotWhitelisted();
        
        uint balance = IERC20(tokenAddress).balanceOf(address(this));
        if (balance < tokenAmount) revert InsufficientBalance({
                available: balance,
                required: tokenAmount
        });
        
        IERC20(tokenAddress).safeTransfer(owner, tokenAmount);
        emit Recovered(tokenAddress, tokenAmount);
    }

    /**
     * @dev It's possible to owner whitelist the underlying token
     * and do some kind of rugpull. To prevent that, it'recommended
     * that owner is a multisig address. Also, it emits an event
     * of changes in the ERC20 whitelist as a safety check.
     * @notice Owner can whitelist an ERC20 to recover it afterwards.
     * Emits and event to notify all users about it 
     * @param flag: true to allow recover for the token
     */
    function changeWhitelistRecoverERC20(address tokenAddress, bool flag) external onlyOwner {
        whitelistRecoverERC20[tokenAddress] = flag;
        emit ChangeWhitelistERC20(tokenAddress, flag);
    }

    /**
     * @notice Added to support to recover ERC721 
     */
    function recoverERC721(address tokenAddress, uint256 tokenId) external onlyOwner {
        IERC721(tokenAddress).safeTransferFrom(address(this), owner, tokenId);
        emit RecoveredNFT(tokenAddress, tokenId);
    }

    /* ========== MODIFIERS ========== */

    /**
     * @dev Update user rewards accordlingly to
     * the current timestamp.
     */
    modifier updateReward(address owner) {
        rewardPerTokenStored = rewardPerToken(address(0));
        lastUpdateTime = lastTimeRewardApplicable(address(0));

        if (owner != address(0)) {
            if (accounts[owner].rewardPerTokenPaid == 0)
                accounts[owner].rewardPerTokenPaid = rewardPerTokenStored;
            accounts[owner].dueDate = IVeVault(vault).unlockDate(owner);
            accounts[owner].rewards = earned(owner);
            accounts[owner].rewardPerTokenPaid = rewardPerToken(address(0));
        }
        _;
    }

    /* ========== EVENTS ========== */

    event RewardAdded(uint256 reward);
    event RewardPaid(address indexed user, uint256 reward);
    event RewardsDurationUpdated(uint256 newDuration);
    event NotifyDeposit(address indexed user, uint256 rewardPerTokenPaid, uint256 dueDate);
    event Recovered(address token, uint256 amount);
    event RecoveredNFT(address tokenAddress, uint256 tokenId);
    event ChangeWhitelistERC20(address indexed tokenAddress, bool whitelistState);
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_vault","type":"address"},{"internalType":"address","name":"_rewardsDistribution","type":"address"},{"internalType":"address","name":"_rewardsToken","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"uint256","name":"available","type":"uint256"},{"internalType":"uint256","name":"required","type":"uint256"}],"name":"InsufficientBalance","type":"error"},{"inputs":[],"name":"NotWhitelisted","type":"error"},{"inputs":[{"internalType":"uint256","name":"finish","type":"uint256"}],"name":"RewardPeriodNotComplete","type":"error"},{"inputs":[],"name":"RewardTooHigh","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"tokenAddress","type":"address"},{"indexed":false,"internalType":"bool","name":"whitelistState","type":"bool"}],"name":"ChangeWhitelistERC20","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"rewardPerTokenPaid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"dueDate","type":"uint256"}],"name":"NotifyDeposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":false,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerNominated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"isPaused","type":"bool"}],"name":"PauseChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Recovered","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"tokenAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"RecoveredNFT","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardAdded","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":"newDuration","type":"uint256"}],"name":"RewardsDurationUpdated","type":"event"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"accounts","outputs":[{"internalType":"uint256","name":"rewardPerTokenPaid","type":"uint256"},{"internalType":"uint256","name":"rewards","type":"uint256"},{"internalType":"uint256","name":"dueDate","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"bool","name":"flag","type":"bool"}],"name":"changeWhitelistRecoverERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"earned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getRewardForDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getVaultAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastPauseTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"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":[{"internalType":"address","name":"_owner","type":"address"}],"name":"nominateNewOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"nominatedOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"notifyDeposit","outputs":[{"components":[{"internalType":"uint256","name":"rewardPerTokenPaid","type":"uint256"},{"internalType":"uint256","name":"rewards","type":"uint256"},{"internalType":"uint256","name":"dueDate","type":"uint256"}],"internalType":"struct Rewards.Account","name":"","type":"tuple"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"reward","type":"uint256"}],"name":"notifyRewardAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"periodFinish","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"uint256","name":"tokenAmount","type":"uint256"}],"name":"recoverERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"recoverERC721","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"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":[],"name":"rewardsDistribution","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardsDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardsToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"_paused","type":"bool"}],"name":"setPaused","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_rewardsDistribution","type":"address"}],"name":"setRewardsDistribution","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rewardsDuration","type":"uint256"}],"name":"setRewardsDuration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"vault","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"whitelistRecoverERC20","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]

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

0x608060405234801561001057600080fd5b50600436106101d95760003560e01c806379ba509711610104578063c8f33c91116100a2578063df136d6511610071578063df136d651461041b578063ebe2b12b14610424578063f12297771461042d578063fbfa77cf1461044057600080fd5b8063c8f33c91146103d4578063cc1a378f146103dd578063d1af0c7d146103f0578063d85ab1111461040857600080fd5b80638980f11f116100de5780638980f11f146103825780638da5cb5b146103955780638daf78af146103a857806391b4ded9146103cb57600080fd5b806379ba50971461035e5780637b0a47ee14610366578063819d4cc61461036f57600080fd5b80633d18b9121161017c5780635e5c06e21161014b5780635e5c06e2146102c6578063638634ee1461031057806365cacaa414610323578063691529d71461033457600080fd5b80633d18b912146102635780633fc6df6e1461026b57806353a47bb7146102965780635c975abb146102a957600080fd5b806319762143116101b8578063197621431461022c5780631c1f78eb1461023f578063386a9525146102475780633c6b16ab1461025057600080fd5b80628cc262146101de5780631627540c1461020457806316c38b3c14610219575b600080fd5b6101f16101ec3660046115c6565b610453565b6040519081526020015b60405180910390f35b6102176102123660046115c6565b61054b565b005b6102176102273660046115ef565b6105a8565b61021761023a3660046115c6565b61061a565b6101f1610644565b6101f160095481565b61021761025e36600461160c565b61065b565b61021761095b565b60025461027e906001600160a01b031681565b6040516001600160a01b0390911681526020016101fb565b60015461027e906001600160a01b031681565b6005546102b69060ff1681565b60405190151581526020016101fb565b6102f56102d43660046115c6565b600c6020526000908152604090208054600182015460029092015490919083565b604080519384526020840192909252908201526060016101fb565b6101f161031e3660046115c6565b610b1c565b6006546001600160a01b031661027e565b61033c610bb3565b60408051825181526020808401519082015291810151908201526060016101fb565b610217610db3565b6101f160085481565b61021761037d366004611625565b610e9d565b610217610390366004611625565b610f58565b60005461027e906001600160a01b031681565b6102b66103b63660046115c6565b600d6020526000908152604090205460ff1681565b6101f160045481565b6101f1600a5481565b6102176103eb36600461160c565b61108e565b60055461027e9061010090046001600160a01b031681565b61021761041636600461164f565b6110f3565b6101f1600b5481565b6101f160075481565b6101f161043b3660046115c6565b611153565b60065461027e906001600160a01b031681565b60008061045f83611153565b6001600160a01b0384166000908152600c60205260408120549192508183111561051b57670de0b6b3a7640000610496838561169c565b6006546040516370a0823160e01b81526001600160a01b038981166004830152909116906370a0823190602401602060405180830381865afa1580156104e0573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061050491906116b3565b61050e91906116cc565b61051891906116eb565b90505b6001600160a01b0385166000908152600c602052604090206001015461054290829061170d565b95945050505050565b61055361128a565b600180546001600160a01b0319166001600160a01b0383169081179091556040519081527f906a1c6bd7e3091ea86693dd029a831c19049ce77f1dce2ce0bab1cacbabce22906020015b60405180910390a150565b6105b061128a565b60055460ff16151581151514610617576005805460ff191682151590811790915560ff16156105de57426004555b60055460405160ff909116151581527f8fb6c181ee25a520cf3dd6565006ef91229fcfe5a989566c2a3b8c115570cec59060200161059d565b50565b61062261128a565b600280546001600160a01b0319166001600160a01b0392909216919091179055565b600060095460085461065691906116cc565b905090565b6002546001600160a01b031633146106cd5760405162461bcd60e51b815260206004820152602a60248201527f43616c6c6572206973206e6f742052657761726473446973747269627574696f6044820152691b8818dbdb9d1c9858dd60b21b60648201526084015b60405180910390fd5b60006106d96000611153565b600b556106e66000610b1c565b600a556001600160a01b03811615610809576001600160a01b0381166000908152600c6020526040812054900361073457600b546001600160a01b0382166000908152600c60205260409020555b6006546040516324e66b4f60e11b81526001600160a01b038381166004830152909116906349ccd69e90602401602060405180830381865afa15801561077e573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906107a291906116b3565b6001600160a01b0382166000908152600c60205260409020600201556107c781610453565b6001600160a01b0382166000908152600c60205260408120600101919091556107ef90611153565b6001600160a01b0382166000908152600c60205260409020555b60075442106108275760095461081f90836116eb565b600855610869565b600042600754610837919061169c565b905060006008548261084991906116cc565b600954909150610859828661170d565b61086391906116eb565b60085550505b6005546040516370a0823160e01b815230600482015260009161010090046001600160a01b0316906370a0823190602401602060405180830381865afa1580156108b7573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906108db91906116b3565b9050600954816108eb91906116eb565b600854111561090d5760405163474c247160e01b815260040160405180910390fd5b42600a81905560095461091f9161170d565b6007556040518381527fde88a922e0d3b88b24e9623efeb464919c6bf9f66857a65e2bfcf2ce87a9433d906020015b60405180910390a1505050565b336109666000611153565b600b556109736000610b1c565b600a556001600160a01b03811615610a96576001600160a01b0381166000908152600c602052604081205490036109c157600b546001600160a01b0382166000908152600c60205260409020555b6006546040516324e66b4f60e11b81526001600160a01b038381166004830152909116906349ccd69e90602401602060405180830381865afa158015610a0b573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610a2f91906116b3565b6001600160a01b0382166000908152600c6020526040902060020155610a5481610453565b6001600160a01b0382166000908152600c6020526040812060010191909155610a7c90611153565b6001600160a01b0382166000908152600c60205260409020555b336000908152600c602052604090206001015480610ab2575050565b336000818152600c6020526040812060010155600554610ae2916101009091046001600160a01b031690836112fe565b60405181815233907fe2403640ba68fed3a2f88b7557551d1993f84b99bb10ff833f0cf8db0c5e0486906020015b60405180910390a25050565b60006001600160a01b03821615801590610b5257506007546001600160a01b0383166000908152600c6020526040902060020154105b15610ba2576001600160a01b0382166000908152600c60205260409020600201544210610b9a576001600160a01b0382166000908152600c6020526040902060020154610b9c565b425b92915050565b6007544210610b9a57600754610b9c565b610bd760405180606001604052806000815260200160008152602001600081525090565b33610be26000611153565b600b55610bef6000610b1c565b600a556001600160a01b03811615610d12576001600160a01b0381166000908152600c60205260408120549003610c3d57600b546001600160a01b0382166000908152600c60205260409020555b6006546040516324e66b4f60e11b81526001600160a01b038381166004830152909116906349ccd69e90602401602060405180830381865afa158015610c87573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610cab91906116b3565b6001600160a01b0382166000908152600c6020526040902060020155610cd081610453565b6001600160a01b0382166000908152600c6020526040812060010191909155610cf890611153565b6001600160a01b0382166000908152600c60205260409020555b600080546001600160a01b03168152600c6020908152604091829020805460029091015483519182529181019190915233917f289612937eedf6241fafcdf01e3dd2fca195f2eceb2fe82a9baeeee6408be551910160405180910390a25050600080546001600160a01b03168152600c6020908152604091829020825160608101845281548152600182015492810192909252600201549181019190915290565b6001546001600160a01b03163314610e2b5760405162461bcd60e51b815260206004820152603560248201527f596f75206d757374206265206e6f6d696e61746564206265666f726520796f7560448201527402063616e20616363657074206f776e65727368697605c1b60648201526084016106c4565b600054600154604080516001600160a01b0393841681529290911660208301527fb532073b38c83145e3e5135377a08bf9aab55bc0fd7c1179cd4fb995d2a5159c910160405180910390a160018054600080546001600160a01b03199081166001600160a01b03841617909155169055565b610ea561128a565b600054604051632142170760e11b81523060048201526001600160a01b03918216602482015260448101839052908316906342842e0e90606401600060405180830381600087803b158015610ef957600080fd5b505af1158015610f0d573d6000803e3d6000fd5b5050604080516001600160a01b0386168152602081018590527f04de91139be5e8b4eaa61555ab706f4b8ba6be2552d0e92549fd256d2b2ce528935001905060405180910390a15050565b610f6061128a565b6001600160a01b0382166000908152600d602052604081205460ff1615159003610f9d57604051630b094f2760e31b815260040160405180910390fd5b6040516370a0823160e01b81523060048201526000906001600160a01b038416906370a0823190602401602060405180830381865afa158015610fe4573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061100891906116b3565b9050818110156110355760405163cf47918160e01b815260048101829052602481018390526044016106c4565b60005461104f906001600160a01b038581169116846112fe565b604080516001600160a01b0385168152602081018490527f8c1256b8896378cd5044f80c202f9772b9d77dc85c8a6eb51967210b09bfaa28910161094e565b61109661128a565b60075442116110be5760075460405163301fe56760e01b81526004016106c491815260200190565b60098190556040518181527ffb46ca5a5e06d4540d6387b930a7c978bce0db5f449ec6b3f5d07c6e1d44f2d39060200161059d565b6110fb61128a565b6001600160a01b0382166000818152600d6020908152604091829020805460ff191685151590811790915591519182527f14ed3fddefc3adc7cbd4d30bda1670cbd32e04df245471b8b9f85d2c50d27bbc9101610b10565b600080600660009054906101000a90046001600160a01b03166001600160a01b03166318160ddd6040518163ffffffff1660e01b8152600401602060405180830381865afa1580156111a9573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906111cd91906116b3565b9050806000036111e1575050600b54919050565b60006111ec84610b1c565b9050600a54811015611245578160085482600a5461120a919061169c565b61121491906116cc565b61122690670de0b6b3a76400006116cc565b61123091906116eb565b600b5461123d919061169c565b949350505050565b81600854600a5483611257919061169c565b61126191906116cc565b61127390670de0b6b3a76400006116cc565b61127d91906116eb565b600b5461123d919061170d565b6000546001600160a01b031633146112fc5760405162461bcd60e51b815260206004820152602f60248201527f4f6e6c792074686520636f6e7472616374206f776e6572206d6179207065726660448201526e37b936903a3434b99030b1ba34b7b760891b60648201526084016106c4565b565b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180516001600160e01b031663a9059cbb60e01b179052611350908490611355565b505050565b60006113aa826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b03166114279092919063ffffffff16565b80519091501561135057808060200190518101906113c89190611725565b6113505760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6044820152691bdd081cdd58d8d9595960b21b60648201526084016106c4565b60606114368484600085611440565b90505b9392505050565b6060824710156114a15760405162461bcd60e51b815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f6044820152651c8818d85b1b60d21b60648201526084016106c4565b6001600160a01b0385163b6114f85760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e747261637400000060448201526064016106c4565b600080866001600160a01b031685876040516115149190611772565b60006040518083038185875af1925050503d8060008114611551576040519150601f19603f3d011682016040523d82523d6000602084013e611556565b606091505b5091509150611566828286611571565b979650505050505050565b60608315611580575081611439565b8251156115905782518084602001fd5b8160405162461bcd60e51b81526004016106c4919061178e565b80356001600160a01b03811681146115c157600080fd5b919050565b6000602082840312156115d857600080fd5b611439826115aa565b801515811461061757600080fd5b60006020828403121561160157600080fd5b8135611439816115e1565b60006020828403121561161e57600080fd5b5035919050565b6000806040838503121561163857600080fd5b611641836115aa565b946020939093013593505050565b6000806040838503121561166257600080fd5b61166b836115aa565b9150602083013561167b816115e1565b809150509250929050565b634e487b7160e01b600052601160045260246000fd5b6000828210156116ae576116ae611686565b500390565b6000602082840312156116c557600080fd5b5051919050565b60008160001904831182151516156116e6576116e6611686565b500290565b60008261170857634e487b7160e01b600052601260045260246000fd5b500490565b6000821982111561172057611720611686565b500190565b60006020828403121561173757600080fd5b8151611439816115e1565b60005b8381101561175d578181015183820152602001611745565b8381111561176c576000848401525b50505050565b60008251611784818460208701611742565b9190910192915050565b60208152600082518060208401526117ad816040850160208701611742565b601f01601f1916919091016040019291505056fea26469706673582212205954e56aec6fe8a59bb51b84e44f2497596091e20f6ac7efadcd92aedf82f88d64736f6c634300080d0033

0000000000000000000000004a848f44146ca6d1d6aa34bcdf3c41093def176100000000000000000000000044dd83e0598e7a3709cf0b2e59d3319418068a650000000000000000000000004a848f44146ca6d1d6aa34bcdf3c41093def176100000000000000000000000098585dfc8d9e7d48f0b1ae47ce33332cf4237d96

-----Decoded View---------------
Arg [0] : _owner (address): 0x4a848F44146Ca6D1D6AA34bcdF3C41093deF1761
Arg [1] : _vault (address): 0x44dd83E0598e7A3709cF0b2e59D3319418068a65
Arg [2] : _rewardsDistribution (address): 0x4a848F44146Ca6D1D6AA34bcdF3C41093deF1761
Arg [3] : _rewardsToken (address): 0x98585dFc8d9e7D48F0b1aE47ce33332CF4237D96

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 0000000000000000000000004a848f44146ca6d1d6aa34bcdf3c41093def1761
Arg [1] : 00000000000000000000000044dd83e0598e7a3709cf0b2e59d3319418068a65
Arg [2] : 0000000000000000000000004a848f44146ca6d1d6aa34bcdf3c41093def1761
Arg [3] : 00000000000000000000000098585dfc8d9e7d48f0b1ae47ce33332cf4237d96

35232:10027:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38951:490;;;;;;:::i;:::-;;:::i;:::-;;;529:25:1;;;517:2;502:18;38951:490:0;;;;;;;;32236:141;;;;;;:::i;:::-;;:::i;:::-;;33528:500;;;;;;:::i;:::-;;:::i;34638:142::-;;;;;;:::i;:::-;;:::i;39539:118::-;;;:::i;35843:39::-;;;;;;40877:1125;;;;;;:::i;:::-;;:::i;40335:314::-;;;:::i;34364:34::-;;;;;-1:-1:-1;;;;;34364:34:0;;;;;;-1:-1:-1;;;;;1283:32:1;;;1265:51;;1253:2;1238:18;34364:34:0;1119:203:1;32012:29:0;;;;;-1:-1:-1;;;;;32012:29:0;;;33123:18;;;;;;;;;;;;1492:14:1;;1485:22;1467:41;;1455:2;1440:18;33123::0;1327:187:1;36133:43:0;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1721:25:1;;;1777:2;1762:18;;1755:34;;;;1805:18;;;1798:34;1709:2;1694:18;36133:43:0;1519:319:1;37113:364:0;;;;;;:::i;:::-;;:::i;36772:88::-;36847:5;;-1:-1:-1;;;;;36847:5:0;36772:88;;39948:224;;;:::i;:::-;;;;2057:13:1;;2039:32;;2127:4;2115:17;;;2109:24;2087:20;;;2080:54;2178:17;;;2172:24;2150:20;;;2143:54;2027:2;2012:18;39948:224:0;1843:360:1;32385:271:0;;;:::i;35710:29::-;;;;;;43820:220;;;;;;:::i;:::-;;:::i;42528:537::-;;;;;;:::i;:::-;;:::i;31985:20::-;;;;;-1:-1:-1;;;;;31985:20:0;;;36236:53;;;;;;:::i;:::-;;;;;;;;;;;;;;;;33091:25;;;;;;35967:29;;;;;;42151:275;;;;;;:::i;:::-;;:::i;35521:27::-;;;;;;;;-1:-1:-1;;;;;35521:27:0;;;43536:206;;;;;;:::i;:::-;;:::i;36047:35::-;;;;;;35628:31;;;;;;37845:868;;;;;;:::i;:::-;;:::i;35555:20::-;;;;;-1:-1:-1;;;;;35555:20:0;;;38951:490;39003:7;39023:21;39047;39062:5;39047:14;:21::i;:::-;-1:-1:-1;;;;;39100:15:0;;39079:18;39100:15;;;:8;:15;;;;;:34;39023:45;;-1:-1:-1;39184:26:0;;;39180:200;;;39364:4;39305:26;39321:10;39305:13;:26;:::i;:::-;39249:5;;39240:32;;-1:-1:-1;;;39240:32:0;;-1:-1:-1;;;;;1283:32:1;;;39240::0;;;1265:51:1;39249:5:0;;;;39240:25;;1238:18:1;;39240:32:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:92;;;;:::i;:::-;:128;;;;:::i;:::-;39227:141;;39180:200;-1:-1:-1;;;;;39397:15:0;;;;;;:8;:15;;;;;:23;;;:36;;39423:10;;39397:36;:::i;:::-;39390:43;38951:490;-1:-1:-1;;;;;38951:490:0:o;32236:141::-;32694:12;:10;:12::i;:::-;32308:14:::1;:23:::0;;-1:-1:-1;;;;;;32308:23:0::1;-1:-1:-1::0;;;;;32308:23:0;::::1;::::0;;::::1;::::0;;;32347:22:::1;::::0;1265:51:1;;;32347:22:0::1;::::0;1253:2:1;1238:18;32347:22:0::1;;;;;;;;32236:141:::0;:::o;33528:500::-;32694:12;:10;:12::i;:::-;33681:6:::1;::::0;::::1;;33670:17;;::::0;::::1;;33666:56:::0;33704:7:::1;33666:56;33768:6;:16:::0;;-1:-1:-1;;33768:16:0::1;::::0;::::1;;::::0;;::::1;::::0;;;::::1;33853:6:::0;33849:70:::1;;;33892:15;33876:13;:31:::0;33849:70:::1;34013:6;::::0;34000:20:::1;::::0;34013:6:::1;::::0;;::::1;1492:14:1::0;1485:22;1467:41;;34000:20:0::1;::::0;1455:2:1;1440:18;34000:20:0::1;1327:187:1::0;32717:1:0::1;33528:500:::0;:::o;34638:142::-;32694:12;:10;:12::i;:::-;34730:19:::1;:42:::0;;-1:-1:-1;;;;;;34730:42:0::1;-1:-1:-1::0;;;;;34730:42:0;;;::::1;::::0;;;::::1;::::0;;34638:142::o;39539:118::-;39594:7;39634:15;;39621:10;;:28;;;;:::i;:::-;39614:35;;39539:118;:::o;40877:1125::-;34544:19;;-1:-1:-1;;;;;34544:19:0;34530:10;:33;34522:88;;;;-1:-1:-1;;;34522:88:0;;3968:2:1;34522:88:0;;;3950:21:1;4007:2;3987:18;;;3980:30;4046:34;4026:18;;;4019:62;-1:-1:-1;;;4097:18:1;;;4090:40;4147:19;;34522:88:0;;;;;;;;;41038:1:::1;44262:26;44285:1;44262:14;:26::i;:::-;44239:20;:49:::0;44316:36:::1;44349:1;44316:24;:36::i;:::-;44299:14;:53:::0;-1:-1:-1;;;;;44369:19:0;::::1;::::0;44365:377:::1;;-1:-1:-1::0;;;;;44409:15:0;::::1;;::::0;;;:8:::1;:15;::::0;;;;:34;:39;;44405:119:::1;;44504:20;::::0;-1:-1:-1;;;;;44467:15:0;::::1;;::::0;;;:8:::1;:15;::::0;;;;:57;44405:119:::1;44574:5;::::0;44565:33:::1;::::0;-1:-1:-1;;;44565:33:0;;-1:-1:-1;;;;;1283:32:1;;;44565:33:0::1;::::0;::::1;1265:51:1::0;44574:5:0;;::::1;::::0;44565:26:::1;::::0;1238:18:1;;44565:33:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;44539:15:0;::::1;;::::0;;;:8:::1;:15;::::0;;;;:23:::1;;:59:::0;44639:13:::1;44548:5:::0;44639:6:::1;:13::i;:::-;-1:-1:-1::0;;;;;44613:15:0;::::1;;::::0;;;:8:::1;:15;::::0;;;;:23:::1;;:39:::0;;;;44704:26:::1;::::0;:14:::1;:26::i;:::-;-1:-1:-1::0;;;;;44667:15:0;::::1;;::::0;;;:8:::1;:15;::::0;;;;:63;44365:377:::1;41076:12:::2;;41057:15;:31;41053:305;;41127:15;::::0;41118:24:::2;::::0;:6;:24:::2;:::i;:::-;41105:10;:37:::0;41053:305:::2;;;41175:17;41210:15;41195:12;;:30;;;;:::i;:::-;41175:50;;41240:16;41271:10;;41259:9;:22;;;;:::i;:::-;41331:15;::::0;41240:41;;-1:-1:-1;41310:17:0::2;41240:41:::0;41310:6;:17:::2;:::i;:::-;41309:37;;;;:::i;:::-;41296:10;:50:::0;-1:-1:-1;;41053:305:0::2;41740:12;::::0;41733:45:::2;::::0;-1:-1:-1;;;41733:45:0;;41772:4:::2;41733:45;::::0;::::2;1265:51:1::0;41718:12:0::2;::::0;41740::::2;::::0;::::2;-1:-1:-1::0;;;;;41740:12:0::2;::::0;41733:30:::2;::::0;1238:18:1;;41733:45:0::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;41718:60;;41816:15;;41806:7;:25;;;;:::i;:::-;41793:10;;:38;41789:66;;;41840:15;;-1:-1:-1::0;;;41840:15:0::2;;;;;;;;;;;41789:66;41885:15;41868:14;:32:::0;;;41944:15:::2;::::0;41926:33:::2;::::0;::::2;:::i;:::-;41911:12;:48:::0;41975:19:::2;::::0;529:25:1;;;41975:19:0::2;::::0;517:2:1;502:18;41975:19:0::2;;;;;;;;41042:960;34621:1:::1;40877:1125:::0;:::o;40335:314::-;40376:10;44262:26;44285:1;44262:14;:26::i;:::-;44239:20;:49;44316:36;44349:1;44316:24;:36::i;:::-;44299:14;:53;-1:-1:-1;;;;;44369:19:0;;;44365:377;;-1:-1:-1;;;;;44409:15:0;;;;;;:8;:15;;;;;:34;:39;;44405:119;;44504:20;;-1:-1:-1;;;;;44467:15:0;;;;;;:8;:15;;;;;:57;44405:119;44574:5;;44565:33;;-1:-1:-1;;;44565:33:0;;-1:-1:-1;;;;;1283:32:1;;;44565:33:0;;;1265:51:1;44574:5:0;;;;44565:26;;1238:18:1;;44565:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;44539:15:0;;;;;;:8;:15;;;;;:23;;:59;44639:13;44548:5;44639:6;:13::i;:::-;-1:-1:-1;;;;;44613:15:0;;;;;;:8;:15;;;;;:23;;:39;;;;44704:26;;:14;:26::i;:::-;-1:-1:-1;;;;;44667:15:0;;;;;;:8;:15;;;;;:63;44365:377;40425:10:::1;40399:14;40416:20:::0;;;:8:::1;:20;::::0;;;;:28:::1;;::::0;40459:11;40455:24:::1;;40472:7;33528:500:::0;:::o;40455:24::-:1;40508:10;40530:1;40499:20:::0;;;:8:::1;:20;::::0;;;;:28:::1;;:32:::0;40549:12:::1;::::0;40542:53:::1;::::0;40549:12:::1;::::0;;::::1;-1:-1:-1::0;;;;;40549:12:0::1;::::0;40588:6;40542:33:::1;:53::i;:::-;40611:30;::::0;529:25:1;;;40622:10:0::1;::::0;40611:30:::1;::::0;517:2:1;502:18;40611:30:0::1;;;;;;;;40388:261;40335:314:::0;:::o;37113:364::-;37183:7;-1:-1:-1;;;;;37207:19:0;;;;;;:61;;-1:-1:-1;37256:12:0;;-1:-1:-1;;;;;37230:15:0;;;;;;:8;:15;;;;;:23;;;:38;37207:61;37203:186;;;-1:-1:-1;;;;;37310:15:0;;;;;;:8;:15;;;;;:23;;;37292:15;:41;:85;;-1:-1:-1;;;;;37354:15:0;;;;;;:8;:15;;;;;:23;;;37292:85;;;37336:15;37292:85;37285:92;37113:364;-1:-1:-1;;37113:364:0:o;37203:186::-;37424:12;;37406:15;:30;:63;;37457:12;;37406:63;;39948:224;40013:14;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;40013:14:0;39993:10;44262:26;44285:1;44262:14;:26::i;:::-;44239:20;:49;44316:36;44349:1;44316:24;:36::i;:::-;44299:14;:53;-1:-1:-1;;;;;44369:19:0;;;44365:377;;-1:-1:-1;;;;;44409:15:0;;;;;;:8;:15;;;;;:34;:39;;44405:119;;44504:20;;-1:-1:-1;;;;;44467:15:0;;;;;;:8;:15;;;;;:57;44405:119;44574:5;;44565:33;;-1:-1:-1;;;44565:33:0;;-1:-1:-1;;;;;1283:32:1;;;44565:33:0;;;1265:51:1;44574:5:0;;;;44565:26;;1238:18:1;;44565:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;44539:15:0;;;;;;:8;:15;;;;;:23;;:59;44639:13;44548:5;44639:6;:13::i;:::-;-1:-1:-1;;;;;44613:15:0;;;;;;:8;:15;;;;;:23;;:39;;;;44704:26;;:14;:26::i;:::-;-1:-1:-1;;;;;44667:15:0;;;;;;:8;:15;;;;;:63;44365:377;40071:15:::1;40080:5:::0;;-1:-1:-1;;;;;40080:5:0::1;40071:15:::0;;:8:::1;:15;::::0;;;;;;;;:34;;40107:23:::1;::::0;;::::1;::::0;40045:86;;4351:25:1;;;4392:18;;;4385:34;;;;40059:10:0::1;::::0;40045:86:::1;::::0;4324:18:1;40045:86:0::1;;;;;;;-1:-1:-1::0;;40149:15:0::1;40158:5:::0;;-1:-1:-1;;;;;40158:5:0::1;40149:15:::0;;:8:::1;:15;::::0;;;;;;;;40142:22;;::::1;::::0;::::1;::::0;;;;;;40158:5;40142:22;::::1;::::0;;;::::1;::::0;;;;::::1;;::::0;;;;;;;;;39948:224::o;32385:271::-;32454:14;;-1:-1:-1;;;;;32454:14:0;32440:10;:28;32432:94;;;;-1:-1:-1;;;32432:94:0;;4632:2:1;32432:94:0;;;4614:21:1;4671:2;4651:18;;;4644:30;4710:34;4690:18;;;4683:62;-1:-1:-1;;;4761:18:1;;;4754:51;4822:19;;32432:94:0;4430:417:1;32432:94:0;32555:5;;;32562:14;32542:35;;;-1:-1:-1;;;;;32555:5:0;;;5064:34:1;;32562:14:0;;;;5129:2:1;5114:18;;5107:43;32542:35:0;;4999:18:1;32542:35:0;;;;;;;32596:14;;;;32588:22;;-1:-1:-1;;;;;;32588:22:0;;;-1:-1:-1;;;;;32596:14:0;;32588:22;;;;32621:27;;;32385:271::o;43820:220::-;32694:12;:10;:12::i;:::-;43966:5:::1;::::0;43912:69:::1;::::0;-1:-1:-1;;;43912:69:0;;43959:4:::1;43912:69;::::0;::::1;5401:34:1::0;-1:-1:-1;;;;;43966:5:0;;::::1;5451:18:1::0;;;5444:43;5503:18;;;5496:34;;;43912:38:0;;::::1;::::0;::::1;::::0;5336:18:1;;43912:69:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;43997:35:0::1;::::0;;-1:-1:-1;;;;;5733:32:1;;5715:51;;5797:2;5782:18;;5775:34;;;43997:35:0::1;::::0;-1:-1:-1;5688:18:1;;-1:-1:-1;43997:35:0::1;;;;;;;43820:220:::0;;:::o;42528:537::-;32694:12;:10;:12::i;:::-;-1:-1:-1;;;;;42627:35:0;::::1;;::::0;;;:21:::1;:35;::::0;;;;;::::1;;:44;;::::0;;42623:73:::1;;42680:16;;-1:-1:-1::0;;;42680:16:0::1;;;;;;;;;;;42623:73;42732:45;::::0;-1:-1:-1;;;42732:45:0;;42771:4:::1;42732:45;::::0;::::1;1265:51:1::0;42717:12:0::1;::::0;-1:-1:-1;;;;;42732:30:0;::::1;::::0;::::1;::::0;1238:18:1;;42732:45:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;42717:60;;42802:11;42792:7;:21;42788:143;;;42822:109;::::0;-1:-1:-1;;;42822:109:0;;::::1;::::0;::::1;4351:25:1::0;;;4392:18;;;4385:34;;;4324:18;;42822:109:0::1;4177:248:1::0;42788:143:0::1;42986:5;::::0;42952:53:::1;::::0;-1:-1:-1;;;;;42952:33:0;;::::1;::::0;42986:5:::1;42993:11:::0;42952:33:::1;:53::i;:::-;43021:36;::::0;;-1:-1:-1;;;;;5733:32:1;;5715:51;;5797:2;5782:18;;5775:34;;;43021:36:0::1;::::0;5688:18:1;43021:36:0::1;5541:274:1::0;42151:275:0;32694:12;:10;:12::i;:::-;42258::::1;;42239:15;:31;42235:81;;42303:12;;42279:37;;-1:-1:-1::0;;;42279:37:0::1;;;;;;529:25:1::0;;517:2;502:18;;383:177;42235:81:0::1;42329:15;:34:::0;;;42379:39:::1;::::0;529:25:1;;;42379:39:0::1;::::0;517:2:1;502:18;42379:39:0::1;383:177:1::0;43536:206:0;32694:12;:10;:12::i;:::-;-1:-1:-1;;;;;43636:35:0;::::1;;::::0;;;:21:::1;:35;::::0;;;;;;;;:42;;-1:-1:-1;;43636:42:0::1;::::0;::::1;;::::0;;::::1;::::0;;;43694:40;;1467:41:1;;;43694:40:0::1;::::0;1440:18:1;43694:40:0::1;1327:187:1::0;37845:868:0;37905:7;37925:20;37957:5;;;;;;;;;-1:-1:-1;;;;;37957:5:0;-1:-1:-1;;;;;37948:27:0;;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;37925:52;;37994:12;38010:1;37994:17;37990:77;;-1:-1:-1;;38035:20:0;;;37845:868;-1:-1:-1;37845:868:0:o;37990:77::-;38077:20;38100:31;38125:5;38100:24;:31::i;:::-;38077:54;;38260:14;;38245:12;:29;38241:258;;;38456:12;38394:10;;38357:12;38340:14;;:29;;;;:::i;:::-;38339:65;;;;:::i;:::-;:93;;38428:4;38339:93;:::i;:::-;:129;;;;:::i;:::-;38298:20;;:189;;;;:::i;:::-;38291:196;37845:868;-1:-1:-1;;;;37845:868:0:o;38241:258::-;38674:12;38612:10;;38573:14;;38558:12;:29;;;;:::i;:::-;38557:65;;;;:::i;:::-;:93;;38646:4;38557:93;:::i;:::-;:129;;;;:::i;:::-;38516:20;;:189;;;;:::i;32734:133::-;32802:5;;-1:-1:-1;;;;;32802:5:0;32788:10;:19;32780:79;;;;-1:-1:-1;;;32780:79:0;;6022:2:1;32780:79:0;;;6004:21:1;6061:2;6041:18;;;6034:30;6100:34;6080:18;;;6073:62;-1:-1:-1;;;6151:18:1;;;6144:45;6206:19;;32780:79:0;5820:411:1;32780:79:0;32734:133::o;20781:211::-;20925:58;;;-1:-1:-1;;;;;5733:32:1;;20925:58:0;;;5715:51:1;5782:18;;;;5775:34;;;20925:58:0;;;;;;;;;;5688:18:1;;;;20925:58:0;;;;;;;;-1:-1:-1;;;;;20925:58:0;-1:-1:-1;;;20925:58:0;;;20898:86;;20918:5;;20898:19;:86::i;:::-;20781:211;;;:::o;23354:716::-;23778:23;23804:69;23832:4;23804:69;;;;;;;;;;;;;;;;;23812:5;-1:-1:-1;;;;;23804:27:0;;;:69;;;;;:::i;:::-;23888:17;;23778:95;;-1:-1:-1;23888:21:0;23884:179;;23985:10;23974:30;;;;;;;;;;;;:::i;:::-;23966:85;;;;-1:-1:-1;;;23966:85:0;;6688:2:1;23966:85:0;;;6670:21:1;6727:2;6707:18;;;6700:30;6766:34;6746:18;;;6739:62;-1:-1:-1;;;6817:18:1;;;6810:40;6867:19;;23966:85:0;6486:406:1;12531:229:0;12668:12;12700:52;12722:6;12730:4;12736:1;12739:12;12700:21;:52::i;:::-;12693:59;;12531:229;;;;;;:::o;13651:510::-;13821:12;13879:5;13854:21;:30;;13846:81;;;;-1:-1:-1;;;13846:81:0;;7099:2:1;13846:81:0;;;7081:21:1;7138:2;7118:18;;;7111:30;7177:34;7157:18;;;7150:62;-1:-1:-1;;;7228:18:1;;;7221:36;7274:19;;13846:81:0;6897:402:1;13846:81:0;-1:-1:-1;;;;;10081:19:0;;;13938:60;;;;-1:-1:-1;;;13938:60:0;;7506:2:1;13938:60:0;;;7488:21:1;7545:2;7525:18;;;7518:30;7584:31;7564:18;;;7557:59;7633:18;;13938:60:0;7304:353:1;13938:60:0;14012:12;14026:23;14053:6;-1:-1:-1;;;;;14053:11:0;14072:5;14079:4;14053:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14011:73;;;;14102:51;14119:7;14128:10;14140:12;14102:16;:51::i;:::-;14095:58;13651:510;-1:-1:-1;;;;;;;13651:510:0:o;16337:712::-;16487:12;16516:7;16512:530;;;-1:-1:-1;16547:10:0;16540:17;;16512:530;16661:17;;:21;16657:374;;16859:10;16853:17;16920:15;16907:10;16903:2;16899:19;16892:44;16657:374;17002:12;16995:20;;-1:-1:-1;;;16995:20:0;;;;;;;;:::i;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:186::-;251:6;304:2;292:9;283:7;279:23;275:32;272:52;;;320:1;317;310:12;272:52;343:29;362:9;343:29;:::i;565:118::-;651:5;644:13;637:21;630:5;627:32;617:60;;673:1;670;663:12;688:241;744:6;797:2;785:9;776:7;772:23;768:32;765:52;;;813:1;810;803:12;765:52;852:9;839:23;871:28;893:5;871:28;:::i;934:180::-;993:6;1046:2;1034:9;1025:7;1021:23;1017:32;1014:52;;;1062:1;1059;1052:12;1014:52;-1:-1:-1;1085:23:1;;934:180;-1:-1:-1;934:180:1:o;2208:254::-;2276:6;2284;2337:2;2325:9;2316:7;2312:23;2308:32;2305:52;;;2353:1;2350;2343:12;2305:52;2376:29;2395:9;2376:29;:::i;:::-;2366:39;2452:2;2437:18;;;;2424:32;;-1:-1:-1;;;2208:254:1:o;2467:315::-;2532:6;2540;2593:2;2581:9;2572:7;2568:23;2564:32;2561:52;;;2609:1;2606;2599:12;2561:52;2632:29;2651:9;2632:29;:::i;:::-;2622:39;;2711:2;2700:9;2696:18;2683:32;2724:28;2746:5;2724:28;:::i;:::-;2771:5;2761:15;;;2467:315;;;;;:::o;2787:127::-;2848:10;2843:3;2839:20;2836:1;2829:31;2879:4;2876:1;2869:15;2903:4;2900:1;2893:15;2919:125;2959:4;2987:1;2984;2981:8;2978:34;;;2992:18;;:::i;:::-;-1:-1:-1;3029:9:1;;2919:125::o;3049:184::-;3119:6;3172:2;3160:9;3151:7;3147:23;3143:32;3140:52;;;3188:1;3185;3178:12;3140:52;-1:-1:-1;3211:16:1;;3049:184;-1:-1:-1;3049:184:1:o;3238:168::-;3278:7;3344:1;3340;3336:6;3332:14;3329:1;3326:21;3321:1;3314:9;3307:17;3303:45;3300:71;;;3351:18;;:::i;:::-;-1:-1:-1;3391:9:1;;3238:168::o;3411:217::-;3451:1;3477;3467:132;;3521:10;3516:3;3512:20;3509:1;3502:31;3556:4;3553:1;3546:15;3584:4;3581:1;3574:15;3467:132;-1:-1:-1;3613:9:1;;3411:217::o;3633:128::-;3673:3;3704:1;3700:6;3697:1;3694:13;3691:39;;;3710:18;;:::i;:::-;-1:-1:-1;3746:9:1;;3633:128::o;6236:245::-;6303:6;6356:2;6344:9;6335:7;6331:23;6327:32;6324:52;;;6372:1;6369;6362:12;6324:52;6404:9;6398:16;6423:28;6445:5;6423:28;:::i;7662:258::-;7734:1;7744:113;7758:6;7755:1;7752:13;7744:113;;;7834:11;;;7828:18;7815:11;;;7808:39;7780:2;7773:10;7744:113;;;7875:6;7872:1;7869:13;7866:48;;;7910:1;7901:6;7896:3;7892:16;7885:27;7866:48;;7662:258;;;:::o;7925:274::-;8054:3;8092:6;8086:13;8108:53;8154:6;8149:3;8142:4;8134:6;8130:17;8108:53;:::i;:::-;8177:16;;;;;7925:274;-1:-1:-1;;7925:274:1:o;8204:383::-;8353:2;8342:9;8335:21;8316:4;8385:6;8379:13;8428:6;8423:2;8412:9;8408:18;8401:34;8444:66;8503:6;8498:2;8487:9;8483:18;8478:2;8470:6;8466:15;8444:66;:::i;:::-;8571:2;8550:15;-1:-1:-1;;8546:29:1;8531:45;;;;8578:2;8527:54;;8204:383;-1:-1:-1;;8204:383:1:o

ipfs://5954e56aec6fe8a59bb51b84e44f2497596091e20f6ac7efadcd92aedf82f88d