Contract 0x21401319caBA905010Ee77A36f87BD176Edc4b96

/**
 *Submitted for verification at polygonscan.com on 2021-06-09
*/

// Sources flattened with hardhat v2.2.1 https://hardhat.org
// SPDX-License-Identifier: MIT
// File @openzeppelin/contracts/utils/[email protected]

pragma solidity ^0.8.0;

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

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

// File @openzeppelin/contracts/access/[email protected]

pragma solidity ^0.8.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 virtual returns (address) {
        return _owner;
    }

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

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        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 @openzeppelin/contracts-upgradeable/proxy/utils/[email protected]

// solhint-disable-next-line compiler-version
pragma solidity ^0.8.0;

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 */
abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     */
    bool private _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Modifier to protect an initializer function from being invoked twice.
     */
    modifier initializer() {
        require(_initializing || !_initialized, "Initializable: contract is already initialized");

        bool isTopLevelCall = !_initializing;
        if (isTopLevelCall) {
            _initializing = true;
            _initialized = true;
        }

        _;

        if (isTopLevelCall) {
            _initializing = false;
        }
    }
}

// File @openzeppelin/contracts/token/ERC20/[email protected]

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

// File @openzeppelin/contracts/utils/[email protected]

pragma solidity ^0.8.0;

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

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// File @openzeppelin/contracts/token/ERC20/utils/[email protected]

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'
        // 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) + 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
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// File @openzeppelin/contracts/security/[email protected]

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 make 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 contracts/vaults/aave/AaveDataTypes.sol

pragma solidity 0.8.4;

library DataTypes {
    // refer to the whitepaper, section 1.1 basic concepts for a formal description of these properties.
    struct ReserveData {
        //stores the reserve configuration
        ReserveConfigurationMap configuration;
        //the liquidity index. Expressed in ray
        uint128 liquidityIndex;
        //variable borrow index. Expressed in ray
        uint128 variableBorrowIndex;
        //the current supply rate. Expressed in ray
        uint128 currentLiquidityRate;
        //the current variable borrow rate. Expressed in ray
        uint128 currentVariableBorrowRate;
        //the current stable borrow rate. Expressed in ray
        uint128 currentStableBorrowRate;
        uint40 lastUpdateTimestamp;
        //tokens addresses
        address aTokenAddress;
        address stableDebtTokenAddress;
        address variableDebtTokenAddress;
        //address of the interest rate strategy
        address interestRateStrategyAddress;
        //the id of the reserve. Represents the position in the list of the active reserves
        uint8 id;
    }

    struct ReserveConfigurationMap {
        //bit 0-15: LTV
        //bit 16-31: Liq. threshold
        //bit 32-47: Liq. bonus
        //bit 48-55: Decimals
        //bit 56: Reserve is active
        //bit 57: reserve is frozen
        //bit 58: borrowing is enabled
        //bit 59: stable rate borrowing enabled
        //bit 60-63: reserved
        //bit 64-79: reserve factor
        uint256 data;
    }

    struct UserConfigurationMap {
        uint256 data;
    }

    enum InterestRateMode {NONE, STABLE, VARIABLE}
}

// File contracts/vaults/aave/IAaveLendingPool.sol

pragma solidity 0.8.4;

pragma experimental ABIEncoderV2;

interface ILendingPool {
    /**
     * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.
     * - E.g. User deposits 100 USDC and gets in return 100 aUSDC
     * @param asset The address of the underlying asset to deposit
     * @param amount The amount to be deposited
     * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
     *   wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
     *   is a different wallet
     * @param referralCode Code used to register the integrator originating the operation, for potential rewards.
     *   0 if the action is executed directly by the user, without any middle-man
     **/
    function deposit(
        address asset,
        uint256 amount,
        address onBehalfOf,
        uint16 referralCode
    ) external;

    /**
     * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned
     * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC
     * @param asset The address of the underlying asset to withdraw
     * @param amount The underlying amount to be withdrawn
     *   - Send the value type(uint256).max in order to withdraw the whole aToken balance
     * @param to Address that will receive the underlying, same as msg.sender if the user
     *   wants to receive it on his own wallet, or a different address if the beneficiary is a
     *   different wallet
     * @return The final amount withdrawn
     **/
    function withdraw(
        address asset,
        uint256 amount,
        address to
    ) external returns (uint256);

    function borrow(
        address asset,
        uint256 amount,
        uint256 interestRateMode,
        uint16 referralCode,
        address onBehalfOf
    ) external;

    function repay(
        address asset,
        uint256 amount,
        uint256 rateMode,
        address onBehalfOf
    ) external returns (uint256);

    function getReserveData(address asset) external view returns (DataTypes.ReserveData memory);
}

// File contracts/vaults/aave/IAaveIncentivesController.sol

pragma solidity 0.8.4;

interface IAaveIncentivesController {
    /**
     * @dev Returns the total of rewards of an user, already accrued + not yet accrued
     * @param user The address of the user
     * @return The rewards
     **/
    function getRewardsBalance(address[] calldata assets, address user) external view returns (uint256);

    /**
     * @dev Claims reward for an user, on all the assets of the lending pool, accumulating the pending rewards
     * @param amount Amount of rewards to claim
     * @param to Address that will be receiving the rewards
     * @return Rewards claimed
     **/
    function claimRewards(
        address[] calldata assets,
        uint256 amount,
        address to
    ) external returns (uint256);

    /**
     * @dev returns the unclaimed rewards of the user
     * @param user the address of the user
     * @return the unclaimed user rewards
     */
    function getUserUnclaimedRewards(address user) external view returns (uint256);

    /**
     * @dev for backward compatibility with previous implementation of the Incentives controller
     */
    function REWARD_TOKEN() external view returns (address);
}

// File contracts/vaults/aave/TreasuryVaultAave.sol

pragma solidity 0.8.4;

contract TreasuryVaultAave is Ownable, Initializable, ReentrancyGuard {
    using SafeERC20 for IERC20;

    IERC20 public asset;
    IERC20 public aToken;
    address public treasury;
    ILendingPool public AaveLendingPool; // Aave lending Pool
    IAaveIncentivesController public AaveIncentivesController;
    uint256 public vaultBalance;

    // EVENTS
    event TreasuryChanged(address indexed newTreasury);
    event Deposited(uint256 amount);
    event Withdrawn(uint256 amount);
    event Profited(uint256 amount);
    event IncentivesClaimed(uint256 amount);

    // MODIFIERS

    modifier onlyTreasury {
        require(_msgSender() == treasury, "!treasury");
        _;
    }

    // Constructor

    function initialize(
        address _asset,
        address _treasury,
        address _aaveLendingPool,
        address _aaveIncentivesController
    ) external initializer onlyOwner {
        asset = IERC20(_asset);
        treasury = _treasury;
        AaveLendingPool = ILendingPool(_aaveLendingPool);
        AaveIncentivesController = IAaveIncentivesController(_aaveIncentivesController);
        aToken = IERC20(_getATokenAddress(_asset));
    }

    // TREASURY functions

    function deposit(uint256 _amount) external onlyTreasury {
        require(_amount > 0, "amount = 0");
        asset.safeTransferFrom(msg.sender, address(this), _amount);
        uint256 newBalance = asset.balanceOf(address(this)); // invest everything in vault
        vaultBalance = newBalance;
        asset.safeApprove(address(AaveLendingPool), 0);
        asset.safeApprove(address(AaveLendingPool), newBalance);
        AaveLendingPool.deposit(address(asset), newBalance, address(this), 0);
        emit Deposited(_amount);
    }

    function withdraw() external onlyTreasury {
        AaveLendingPool.withdraw(address(asset), balanceOfAToken(), address(this));
        uint256 newBalance = asset.balanceOf(address(this)); // withdraw everything in vault
        uint256 profit = 0;
        if (newBalance > vaultBalance) {
            profit = newBalance - vaultBalance;
        }
        asset.safeTransfer(treasury, newBalance);
        vaultBalance = asset.balanceOf(address(this));
        emit Withdrawn(newBalance);
        emit Profited(profit);
    }

    function claimIncetiveRewards() external onlyOwner {
        uint256 unclaimedRewards = getUnclaimedIncentiveRewardsBalance();
        address[] memory _tokens = new address[](1);
        _tokens[0] = address(aToken);
        AaveIncentivesController.claimRewards(_tokens, unclaimedRewards, msg.sender); // claim directly to owner
        emit IncentivesClaimed(unclaimedRewards);
    }

    function getUnclaimedIncentiveRewardsBalance() public view returns (uint256) {
        return AaveIncentivesController.getUserUnclaimedRewards(address(this));
    }

    function balanceOfAToken() public view returns (uint256) {
        return aToken.balanceOf(address(this));
    }

    function _getATokenAddress(address _asset) internal view returns (address) {
        DataTypes.ReserveData memory reserveData = AaveLendingPool.getReserveData(_asset);
        return reserveData.aTokenAddress;
    }

    // ===== VAULT ADMIN FUNCTIONS ===============

    function setTreasury(address _treasury) external onlyOwner {
        require(_treasury != address(0), "Invalid address");
        treasury = _treasury;
        emit TreasuryChanged(_treasury);
    }

    function setIncentiveController(address _aaveIncentivesController) external onlyOwner {
        require(_aaveIncentivesController != address(0), "Invalid address");
        AaveIncentivesController = IAaveIncentivesController(_aaveIncentivesController);
    }

    function executeTransaction(
        address target,
        uint256 value,
        string memory signature,
        bytes memory data
    ) public onlyOwner returns (bytes memory) {
        bytes memory callData;

        if (bytes(signature).length == 0) {
            callData = data;
        } else {
            callData = abi.encodePacked(bytes4(keccak256(bytes(signature))), data);
        }
        // solium-disable-next-line security/no-call-value
        (bool success, bytes memory returnData) = target.call{value: value}(callData);
        require(success, string("TreasuryVaultAave::executeTransaction: Transaction execution reverted."));
        return returnData;
    }

    receive() external payable {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposited","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"IncentivesClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Profited","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newTreasury","type":"address"}],"name":"TreasuryChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdrawn","type":"event"},{"inputs":[],"name":"AaveIncentivesController","outputs":[{"internalType":"contract IAaveIncentivesController","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"AaveLendingPool","outputs":[{"internalType":"contract ILendingPool","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"aToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"asset","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"balanceOfAToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimIncetiveRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"string","name":"signature","type":"string"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"executeTransaction","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getUnclaimedIncentiveRewardsBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_asset","type":"address"},{"internalType":"address","name":"_treasury","type":"address"},{"internalType":"address","name":"_aaveLendingPool","type":"address"},{"internalType":"address","name":"_aaveIncentivesController","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_aaveIncentivesController","type":"address"}],"name":"setIncentiveController","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_treasury","type":"address"}],"name":"setTreasury","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"treasury","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vaultBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

28452:4534:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31974:262;;;;;;;;;;-1:-1:-1;31974:262:0;;;;;:::i;:::-;;:::i;:::-;;28774:27;;;;;;;;;;;;;;;;;;;14683:25:1;;;14671:2;14656:18;28774:27:0;;;;;;;;32244:702;;;;;;;;;;-1:-1:-1;32244:702:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;28564:19::-;;;;;;;;;;-1:-1:-1;28564:19:0;;;;-1:-1:-1;;;;;28564:19:0;;;;;;-1:-1:-1;;;;;6897:32:1;;;6879:51;;6867:2;6852:18;28564:19:0;6834:102:1;30244:536:0;;;;;;;;;;;;;:::i;28617:23::-;;;;;;;;;;-1:-1:-1;28617:23:0;;;;-1:-1:-1;;;;;28617:23:0;;;2815:148;;;;;;;;;;;;;:::i;31188:166::-;;;;;;;;;;;;;:::i;2164:87::-;;;;;;;;;;-1:-1:-1;2210:7:0;2237:6;-1:-1:-1;;;;;2237:6:0;2164:87;;28647:35;;;;;;;;;;-1:-1:-1;28647:35:0;;;;-1:-1:-1;;;;;28647:35:0;;;30788:392;;;;;;;;;;;;;:::i;28590:20::-;;;;;;;;;;-1:-1:-1;28590:20:0;;;;-1:-1:-1;;;;;28590:20:0;;;31362:114;;;;;;;;;;;;;:::i;29693:543::-;;;;;;;;;;-1:-1:-1;29693:543:0;;;;;:::i;:::-;;:::i;31764:202::-;;;;;;;;;;-1:-1:-1;31764:202:0;;;;;:::i;:::-;;:::i;3118:244::-;;;;;;;;;;-1:-1:-1;3118:244:0;;;;;:::i;:::-;;:::i;29192:464::-;;;;;;;;;;-1:-1:-1;29192:464:0;;;;;:::i;:::-;;:::i;28710:57::-;;;;;;;;;;-1:-1:-1;28710:57:0;;;;-1:-1:-1;;;;;28710:57:0;;;31974:262;2210:7;2237:6;-1:-1:-1;;;;;2237:6:0;801:10;2384:23;2376:68;;;;-1:-1:-1;;;2376:68:0;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;32079:39:0;::::1;32071:67;;;::::0;-1:-1:-1;;;32071:67:0;;10937:2:1;32071:67:0::1;::::0;::::1;10919:21:1::0;10976:2;10956:18;;;10949:30;-1:-1:-1;;;10995:18:1;;;10988:45;11050:18;;32071:67:0::1;10909:165:1::0;32071:67:0::1;32149:24;:79:::0;;-1:-1:-1;;;;;;32149:79:0::1;-1:-1:-1::0;;;;;32149:79:0;;;::::1;::::0;;;::::1;::::0;;31974:262::o;32244:702::-;2210:7;2237:6;32416:12;;-1:-1:-1;;;;;2237:6:0;801:10;2384:23;2376:68;;;;-1:-1:-1;;;2376:68:0;;;;;;;:::i;:::-;32441:21:::1;32485:9;32479:23;32506:1;32479:28;32475:179;;;-1:-1:-1::0;32535:4:0;32475:179:::1;;;32623:9;32607:27;;;;;;32637:4;32583:59;;;;;;;;;:::i;:::-;;;;;;;;;;;;;32572:70;;32475:179;32725:12;32739:23:::0;32766:6:::1;-1:-1:-1::0;;;;;32766:11:0::1;32785:5;32792:8;32766:35;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32724:77;;;;32820:7;32829:80;;;;;;;;;;;;;;;;;32812:98;;;;;-1:-1:-1::0;;;32812:98:0::1;;;;;;;;:::i;:::-;-1:-1:-1::0;32928:10:0;32244:702;-1:-1:-1;;;;;;;32244:702:0:o;30244:536::-;29120:8;;-1:-1:-1;;;;;29120:8:0;801:10;-1:-1:-1;;;;;29104:24:0;;29096:46;;;;-1:-1:-1;;;29096:46:0;;12871:2:1;29096:46:0;;;12853:21:1;12910:1;12890:18;;;12883:29;-1:-1:-1;;;12928:18:1;;;12921:39;12977:18;;29096:46:0;12843:158:1;29096:46:0;30297:15:::1;::::0;30330:5:::1;::::0;-1:-1:-1;;;;;30297:15:0;;::::1;::::0;:24:::1;::::0;30330:5:::1;30338:17;:15;:17::i;:::-;30297:74;::::0;-1:-1:-1;;;;;;30297:74:0::1;::::0;;;;;;-1:-1:-1;;;;;8167:15:1;;;30297:74:0::1;::::0;::::1;8149:34:1::0;8199:18;;;8192:34;30365:4:0::1;8242:18:1::0;;;8235:43;8084:18;;30297:74:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;30403:5:0::1;::::0;:30:::1;::::0;-1:-1:-1;;;30403:30:0;;30427:4:::1;30403:30;::::0;::::1;6879:51:1::0;30382:18:0::1;::::0;-1:-1:-1;;;;;30403:5:0::1;::::0;:15:::1;::::0;6852:18:1;;30403:30:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;30382:51;;30476:14;30522:12;;30509:10;:25;30505:92;;;30573:12;::::0;30560:25:::1;::::0;:10;:25:::1;:::i;:::-;30551:34;;30505:92;30626:8;::::0;30607:5:::1;::::0;:40:::1;::::0;-1:-1:-1;;;;;30607:5:0;;::::1;::::0;30626:8:::1;30636:10:::0;30607:18:::1;:40::i;:::-;30673:5;::::0;:30:::1;::::0;-1:-1:-1;;;30673:30:0;;30697:4:::1;30673:30;::::0;::::1;6879:51:1::0;-1:-1:-1;;;;;30673:5:0;;::::1;::::0;:15:::1;::::0;6852:18:1;;30673:30:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;30658:12;:45:::0;30719:21:::1;::::0;14683:25:1;;;30719:21:0::1;::::0;14671:2:1;14656:18;30719:21:0::1;;;;;;;30756:16;::::0;14683:25:1;;;30756:16:0::1;::::0;14671:2:1;14656:18;30756:16:0::1;;;;;;;;29153:1;;30244:536::o:0;2815:148::-;2210:7;2237:6;-1:-1:-1;;;;;2237:6:0;801:10;2384:23;2376:68;;;;-1:-1:-1;;;2376:68:0;;;;;;;:::i;:::-;2922:1:::1;2906:6:::0;;2885:40:::1;::::0;-1:-1:-1;;;;;2906:6:0;;::::1;::::0;2885:40:::1;::::0;2922:1;;2885:40:::1;2953:1;2936:19:::0;;-1:-1:-1;;;;;;2936:19:0::1;::::0;;2815:148::o;31188:166::-;31283:24;;:63;;-1:-1:-1;;;31283:63:0;;31340:4;31283:63;;;6879:51:1;31256:7:0;;-1:-1:-1;;;;;31283:24:0;;:48;;6852:18:1;;31283:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;31276:70;;31188:166;:::o;30788:392::-;2210:7;2237:6;-1:-1:-1;;;;;2237:6:0;801:10;2384:23;2376:68;;;;-1:-1:-1;;;2376:68:0;;;;;;;:::i;:::-;30850:24:::1;30877:37;:35;:37::i;:::-;30952:16;::::0;;30966:1:::1;30952:16:::0;;;;;::::1;::::0;;;30850:64;;-1:-1:-1;30925:24:0::1;::::0;30952:16;::::1;::::0;;::::1;::::0;;::::1;::::0;::::1;-1:-1:-1::0;;31000:6:0::1;::::0;30979:10;;;;-1:-1:-1;;;;;;31000:6:0::1;::::0;30979:10;;-1:-1:-1;31000:6:0::1;::::0;30979:10:::1;;-1:-1:-1::0;;;30979:10:0::1;;;;;;;;;-1:-1:-1::0;;;;;30979:28:0;;::::1;:10;::::0;;::::1;::::0;;;;;:28;31018:24:::1;::::0;:76:::1;::::0;-1:-1:-1;;;31018:76:0;;:24;::::1;::::0;:37:::1;::::0;:76:::1;::::0;31056:7;;31065:16;;31083:10:::1;::::0;31018:76:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;31137:35:0::1;::::0;14683:25:1;;;31137:35:0::1;::::0;14671:2:1;14656:18;31137:35:0::1;14638:76:1::0;31362:114:0;31437:6;;:31;;-1:-1:-1;;;31437:31:0;;31462:4;31437:31;;;6879:51:1;31410:7:0;;-1:-1:-1;;;;;31437:6:0;;:16;;6852:18:1;;31437:31:0;6834:102:1;29693:543:0;29120:8;;-1:-1:-1;;;;;29120:8:0;801:10;-1:-1:-1;;;;;29104:24:0;;29096:46;;;;-1:-1:-1;;;29096:46:0;;12871:2:1;29096:46:0;;;12853:21:1;12910:1;12890:18;;;12883:29;-1:-1:-1;;;12928:18:1;;;12921:39;12977:18;;29096:46:0;12843:158:1;29096:46:0;29778:1:::1;29768:7;:11;29760:34;;;::::0;-1:-1:-1;;;29760:34:0;;14400:2:1;29760:34:0::1;::::0;::::1;14382:21:1::0;14439:2;14419:18;;;14412:30;-1:-1:-1;;;14458:18:1;;;14451:40;14508:18;;29760:34:0::1;14372:160:1::0;29760:34:0::1;29805:5;::::0;:58:::1;::::0;-1:-1:-1;;;;;29805:5:0::1;29828:10;29848:4;29855:7:::0;29805:22:::1;:58::i;:::-;29895:5;::::0;:30:::1;::::0;-1:-1:-1;;;29895:30:0;;29919:4:::1;29895:30;::::0;::::1;6879:51:1::0;29874:18:0::1;::::0;-1:-1:-1;;;;;29895:5:0::1;::::0;:15:::1;::::0;6852:18:1;;29895:30:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;29966:12;:25:::0;;;30028:15:::1;::::0;30002:5:::1;::::0;29874:51;;-1:-1:-1;30002:46:0::1;::::0;-1:-1:-1;;;;;30002:5:0;;::::1;::::0;30028:15:::1;;30002:17;:46::i;:::-;30085:15;::::0;30059:5:::1;::::0;:55:::1;::::0;-1:-1:-1;;;;;30059:5:0;;::::1;::::0;30085:15:::1;30103:10:::0;30059:17:::1;:55::i;:::-;30125:15;::::0;30157:5:::1;::::0;30125:69:::1;::::0;-1:-1:-1;;;30125:69:0;;-1:-1:-1;;;;;30157:5:0;;::::1;30125:69;::::0;::::1;8565:34:1::0;8615:18;;;8608:34;;;30185:4:0::1;8658:18:1::0;;;8651:43;30125:15:0::1;8710:18:1::0;;;8703:47;30125:15:0;::::1;::::0;:23:::1;::::0;8499:19:1;;30125:69:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;30210:18;30220:7;30210:18;;;;14683:25:1::0;;14671:2;14656:18;;14638:76;31764:202:0;2210:7;2237:6;-1:-1:-1;;;;;2237:6:0;801:10;2384:23;2376:68;;;;-1:-1:-1;;;2376:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;31842:23:0;::::1;31834:51;;;::::0;-1:-1:-1;;;31834:51:0;;10937:2:1;31834:51:0::1;::::0;::::1;10919:21:1::0;10976:2;10956:18;;;10949:30;-1:-1:-1;;;10995:18:1;;;10988:45;11050:18;;31834:51:0::1;10909:165:1::0;31834:51:0::1;31896:8;:20:::0;;-1:-1:-1;;;;;;31896:20:0::1;-1:-1:-1::0;;;;;31896:20:0;::::1;::::0;;::::1;::::0;;;31932:26:::1;::::0;::::1;::::0;-1:-1:-1;;31932:26:0::1;31764:202:::0;:::o;3118:244::-;2210:7;2237:6;-1:-1:-1;;;;;2237:6:0;801:10;2384:23;2376:68;;;;-1:-1:-1;;;2376:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;3207:22:0;::::1;3199:73;;;::::0;-1:-1:-1;;;3199:73:0;;11281:2:1;3199:73:0::1;::::0;::::1;11263:21:1::0;11320:2;11300:18;;;11293:30;11359:34;11339:18;;;11332:62;-1:-1:-1;;;11410:18:1;;;11403:36;11456:19;;3199:73:0::1;11253:228:1::0;3199:73:0::1;3309:6;::::0;;3288:38:::1;::::0;-1:-1:-1;;;;;3288:38:0;;::::1;::::0;3309:6;::::1;::::0;3288:38:::1;::::0;::::1;3337:6;:17:::0;;-1:-1:-1;;;;;;3337:17:0::1;-1:-1:-1::0;;;;;3337:17:0;;;::::1;::::0;;;::::1;::::0;;3118:244::o;29192:464::-;4905:13;;-1:-1:-1;;;4905:13:0;;;;;:30;;-1:-1:-1;4923:12:0;;-1:-1:-1;;;4923:12:0;;;;4922:13;4905:30;4897:89;;;;-1:-1:-1;;;4897:89:0;;12095:2:1;4897:89:0;;;12077:21:1;12134:2;12114:18;;;12107:30;12173:34;12153:18;;;12146:62;-1:-1:-1;;;12224:18:1;;;12217:44;12278:19;;4897:89:0;12067:236:1;4897:89:0;4999:19;5022:13;-1:-1:-1;;;5022:13:0;;;;5021:14;5046:101;;;;5081:13;:20;;-1:-1:-1;;;;5116:19:0;-1:-1:-1;;;5116:19:0;;;5046:101;2210:7;2237:6;-1:-1:-1;;;;;2237:6:0;801:10;2384:23:::1;2376:68;;;;-1:-1:-1::0;;;2376:68:0::1;;;;;;;:::i;:::-;29393:5:::2;:22:::0;;-1:-1:-1;;;;;29393:22:0;;::::2;-1:-1:-1::0;;;;;;29393:22:0;;::::2;;::::0;;;29426:8:::2;:20:::0;;;;::::2;::::0;;::::2;;::::0;;29457:15:::2;:48:::0;;;;::::2;::::0;;::::2;;::::0;;29516:24:::2;:79:::0;;;;::::2;::::0;;;::::2;::::0;;;::::2;::::0;;29622:25:::2;29408:6:::0;29622:17:::2;:25::i;:::-;29606:6;:42:::0;;-1:-1:-1;;;;;;29606:42:0::2;-1:-1:-1::0;;;;;29606:42:0;;;::::2;::::0;;;::::2;::::0;;5173:68;;;;5224:5;5208:21;;-1:-1:-1;;;;5208:21:0;;;5173:68;29192:464;;;;;:::o;16982:211::-;17126:58;;-1:-1:-1;;;;;7822:32:1;;17126:58:0;;;7804:51:1;7871:18;;;7864:34;;;17099:86:0;;17119:5;;-1:-1:-1;;;17149:23:0;7777:18:1;;17126:58:0;;;;-1:-1:-1;;17126:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;17126:58:0;-1:-1:-1;;;;;;17126:58:0;;;;;;;;;;17099:19;:86::i;:::-;16982:211;;;:::o;17201:248::-;17372:68;;-1:-1:-1;;;;;7508:15:1;;;17372:68:0;;;7490:34:1;7560:15;;7540:18;;;7533:43;7592:18;;;7585:34;;;17345:96:0;;17365:5;;-1:-1:-1;;;17395:27:0;7425:18:1;;17372:68:0;7407:218:1;17345:96:0;17201:248;;;;:::o;17718:633::-;18122:10;;;18121:62;;-1:-1:-1;18138:39:0;;-1:-1:-1;;;18138:39:0;;18162:4;18138:39;;;7153:34:1;-1:-1:-1;;;;;7223:15:1;;;7203:18;;;7196:43;18138:15:0;;;;;7088:18:1;;18138:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;18121:62;18113:129;;;;-1:-1:-1;;;18113:129:0;;13977:2:1;18113:129:0;;;13959:21:1;14016:2;13996:18;;;13989:30;14055:34;14035:18;;;14028:62;-1:-1:-1;;;14106:18:1;;;14099:52;14168:19;;18113:129:0;13949:244:1;18113:129:0;18280:62;;-1:-1:-1;;;;;7822:32:1;;18280:62:0;;;7804:51:1;7871:18;;;7864:34;;;18253:90:0;;18273:5;;-1:-1:-1;;;18303:22:0;7777:18:1;;18280:62:0;7759:145:1;31484:218:0;31613:15;;:38;;-1:-1:-1;;;31613:38:0;;-1:-1:-1;;;;;6897:32:1;;;31613:38:0;;;6879:51:1;31550:7:0;;;;31613:15;;;:30;;6852:18:1;;31613:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;31669:25;;;;31484:218;-1:-1:-1;;;31484:218:0:o;19572:774::-;19996:23;20022:69;20050:4;20022:69;;;;;;;;;;;;;;;;;20030:5;-1:-1:-1;;;;;20022:27:0;;;:69;;;;;:::i;:::-;20106:17;;19996:95;;-1:-1:-1;20106:21:0;20102:237;;20261:10;20250:30;;;;;;;;;;;;:::i;:::-;20242:85;;;;-1:-1:-1;;;20242:85:0;;13566:2:1;20242:85:0;;;13548:21:1;13605:2;13585:18;;;13578:30;13644:34;13624:18;;;13617:62;-1:-1:-1;;;13695:18:1;;;13688:40;13745:19;;20242:85:0;13538:232:1;11802:229:0;11939:12;11971:52;11993:6;12001:4;12007:1;12010:12;11971:21;:52::i;:::-;11964:59;;11802:229;;;;;;:::o;12922:571::-;13092:12;13150:5;13125:21;:30;;13117:81;;;;-1:-1:-1;;;13117:81:0;;11688:2:1;13117:81:0;;;11670:21:1;11727:2;11707:18;;;11700:30;11766:34;11746:18;;;11739:62;-1:-1:-1;;;11817:18:1;;;11810:36;11863:19;;13117:81:0;11660:228:1;13117:81:0;9242:20;;13209:60;;;;-1:-1:-1;;;13209:60:0;;13208:2:1;13209:60:0;;;13190:21:1;13247:2;13227:18;;;13220:30;13286:31;13266:18;;;13259:59;13335:18;;13209:60:0;13180:179:1;13209:60:0;13343:12;13357:23;13384:6;-1:-1:-1;;;;;13384:11:0;13403:5;13410:4;13384:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13342:73;;;;13433:52;13451:7;13460:10;13472:12;13433:17;:52::i;:::-;13426:59;12922:571;-1:-1:-1;;;;;;;12922:571:0:o;15571:777::-;15721:12;15750:7;15746:595;;;-1:-1:-1;15781:10:0;15774:17;;15746:595;15895:17;;:21;15891:439;;16158:10;16152:17;16219:15;16206:10;16202:2;16198:19;16191:44;16106:148;16301:12;16294:20;;-1:-1:-1;;;16294:20:0;;;;;;;;:::i;14:631:1:-;78:5;108:18;149:2;141:6;138:14;135:2;;;155:18;;:::i;:::-;230:2;224:9;198:2;284:15;;-1:-1:-1;;280:24:1;;;306:2;276:33;272:42;260:55;;;330:18;;;350:22;;;327:46;324:2;;;376:18;;:::i;:::-;416:10;412:2;405:22;445:6;436:15;;475:6;467;460:22;515:3;506:6;501:3;497:16;494:25;491:2;;;532:1;529;522:12;491:2;582:6;577:3;570:4;562:6;558:17;545:44;637:1;630:4;621:6;613;609:19;605:30;598:41;;;;88:557;;;;;:::o;650:138::-;729:13;;751:31;729:13;751:31;:::i;:::-;710:78;;;:::o;793:434::-;874:5;922:4;910:9;905:3;901:19;897:30;894:2;;;944:5;937;930:20;894:2;981;975:9;1023:4;1015:6;1011:17;1094:6;1082:10;1079:22;1058:18;1046:10;1043:34;1040:62;1037:2;;;1105:18;;:::i;:::-;1141:2;1134:22;1204:16;;1189:32;;-1:-1:-1;1174:6:1;884:343;-1:-1:-1;884:343:1:o;1232:192::-;1311:13;;1364:34;1353:46;;1343:57;;1333:2;;1414:1;1411;1404:12;1429:169;1507:13;;1560:12;1549:24;;1539:35;;1529:2;;1588:1;1585;1578:12;1603:160;1680:13;;1733:4;1722:16;;1712:27;;1702:2;;1753:1;1750;1743:12;1768:257;1827:6;1880:2;1868:9;1859:7;1855:23;1851:32;1848:2;;;1901:6;1893;1886:22;1848:2;1945:9;1932:23;1964:31;1989:5;1964:31;:::i;2030:681::-;2116:6;2124;2132;2140;2193:3;2181:9;2172:7;2168:23;2164:33;2161:2;;;2215:6;2207;2200:22;2161:2;2259:9;2246:23;2278:31;2303:5;2278:31;:::i;:::-;2328:5;-1:-1:-1;2385:2:1;2370:18;;2357:32;2398:33;2357:32;2398:33;:::i;:::-;2450:7;-1:-1:-1;2509:2:1;2494:18;;2481:32;2522:33;2481:32;2522:33;:::i;:::-;2574:7;-1:-1:-1;2633:2:1;2618:18;;2605:32;2646:33;2605:32;2646:33;:::i;:::-;2151:560;;;;-1:-1:-1;2151:560:1;;-1:-1:-1;;2151:560:1:o;2716:1052::-;2821:6;2829;2837;2845;2898:3;2886:9;2877:7;2873:23;2869:33;2866:2;;;2920:6;2912;2905:22;2866:2;2964:9;2951:23;2983:31;3008:5;2983:31;:::i;:::-;3033:5;-1:-1:-1;3085:2:1;3070:18;;3057:32;;-1:-1:-1;3140:2:1;3125:18;;3112:32;3163:18;3193:14;;;3190:2;;;3225:6;3217;3210:22;3190:2;3268:6;3257:9;3253:22;3243:32;;3313:7;3306:4;3302:2;3298:13;3294:27;3284:2;;3340:6;3332;3325:22;3284:2;3368:73;3433:7;3428:2;3415:16;3410:2;3406;3402:11;3368:73;:::i;:::-;3358:83;;3494:2;3483:9;3479:18;3466:32;3450:48;;3523:2;3513:8;3510:16;3507:2;;;3544:6;3536;3529:22;3507:2;-1:-1:-1;3572:24:1;;3627:4;3619:13;;3615:27;-1:-1:-1;3605:2:1;;3661:6;3653;3646:22;3605:2;3689:73;3754:7;3749:2;3736:16;3731:2;3727;3723:11;3689:73;:::i;:::-;3679:83;;;2856:912;;;;;;;:::o;3773:297::-;3840:6;3893:2;3881:9;3872:7;3868:23;3864:32;3861:2;;;3914:6;3906;3899:22;3861:2;3951:9;3945:16;4004:5;3997:13;3990:21;3983:5;3980:32;3970:2;;4031:6;4023;4016:22;4075:1342;4173:6;4226:3;4214:9;4205:7;4201:23;4197:33;4194:2;;;4248:6;4240;4233:22;4194:2;4279:17;;:::i;:::-;4319:72;4383:7;4372:9;4319:72;:::i;:::-;4312:5;4305:87;4424:49;4469:2;4458:9;4454:18;4424:49;:::i;:::-;4419:2;4412:5;4408:14;4401:73;4506:49;4551:2;4540:9;4536:18;4506:49;:::i;:::-;4501:2;4494:5;4490:14;4483:73;4588:49;4633:2;4622:9;4618:18;4588:49;:::i;:::-;4583:2;4576:5;4572:14;4565:73;4671:50;4716:3;4705:9;4701:19;4671:50;:::i;:::-;4665:3;4658:5;4654:15;4647:75;4755:50;4800:3;4789:9;4785:19;4755:50;:::i;:::-;4749:3;4742:5;4738:15;4731:75;4839:49;4883:3;4872:9;4868:19;4839:49;:::i;:::-;4833:3;4826:5;4822:15;4815:74;4922:50;4967:3;4956:9;4952:19;4922:50;:::i;:::-;4916:3;4909:5;4905:15;4898:75;4992:3;5027:49;5072:2;5061:9;5057:18;5027:49;:::i;:::-;5011:14;;;5004:73;5096:3;5131:49;5161:18;;;5131:49;:::i;:::-;5115:14;;;5108:73;5200:3;5235:49;5265:18;;;5235:49;:::i;:::-;5219:14;;;5212:73;5304:3;5339:47;5367:18;;;5339:47;:::i;:::-;5323:14;;;5316:71;5327:5;4184:1233;-1:-1:-1;;;4184:1233:1:o;5422:190::-;5481:6;5534:2;5522:9;5513:7;5509:23;5505:32;5502:2;;;5555:6;5547;5540:22;5502:2;-1:-1:-1;5583:23:1;;5492:120;-1:-1:-1;5492:120:1:o;5617:194::-;5687:6;5740:2;5728:9;5719:7;5715:23;5711:32;5708:2;;;5761:6;5753;5746:22;5708:2;-1:-1:-1;5789:16:1;;5698:113;-1:-1:-1;5698:113:1:o;5816:257::-;5857:3;5895:5;5889:12;5922:6;5917:3;5910:19;5938:63;5994:6;5987:4;5982:3;5978:14;5971:4;5964:5;5960:16;5938:63;:::i;:::-;6055:2;6034:15;-1:-1:-1;;6030:29:1;6021:39;;;;6062:4;6017:50;;5865:208;-1:-1:-1;;5865:208:1:o;6078:371::-;-1:-1:-1;;;;;;6263:33:1;;6251:46;;6320:13;;6233:3;;6342:61;6320:13;6392:1;6383:11;;6376:4;6364:17;;6342:61;:::i;:::-;6423:16;;;;6441:1;6419:24;;6241:208;-1:-1:-1;;;6241:208:1:o;6454:274::-;6583:3;6621:6;6615:13;6637:53;6683:6;6678:3;6671:4;6663:6;6659:17;6637:53;:::i;:::-;6706:16;;;;;6591:137;-1:-1:-1;;6591:137:1:o;8761:832::-;9007:2;9019:21;;;9089:13;;8992:18;;;9111:22;;;8959:4;;9187;;9164:3;9149:19;;;9214:15;;;8959:4;9260:195;9274:6;9271:1;9268:13;9260:195;;;9339:13;;-1:-1:-1;;;;;9335:39:1;9323:52;;9395:12;;;;9430:15;;;;9371:1;9289:9;9260:195;;;-1:-1:-1;;;9491:18:1;;;9484:34;;;;-1:-1:-1;;;;;;9554:32:1;;;;9549:2;9534:18;;;9527:60;9472:3;8968:625;-1:-1:-1;8968:625:1:o;9598:217::-;9745:2;9734:9;9727:21;9708:4;9765:44;9805:2;9794:9;9790:18;9782:6;9765:44;:::i;12308:356::-;12510:2;12492:21;;;12529:18;;;12522:30;12588:34;12583:2;12568:18;;12561:62;12655:2;12640:18;;12482:182::o;14719:247::-;14786:2;14780:9;14828:3;14816:16;;14862:18;14847:34;;14883:22;;;14844:62;14841:2;;;14909:18;;:::i;:::-;14945:2;14938:22;14760:206;:::o;14971:228::-;15011:4;15039:1;15036;15033:8;15030:2;;;-1:-1:-1;;;15064:34:1;;15121:4;15118:1;15111:15;15152:4;15071;15139:18;15030:2;-1:-1:-1;15184:9:1;;15020:179::o;15204:258::-;15276:1;15286:113;15300:6;15297:1;15294:13;15286:113;;;15376:11;;;15370:18;15357:11;;;15350:39;15322:2;15315:10;15286:113;;;15417:6;15414:1;15411:13;15408:2;;;-1:-1:-1;;15452:1:1;15434:16;;15427:27;15257:205::o;15467:127::-;15528:10;15523:3;15519:20;15516:1;15509:31;15559:4;15556:1;15549:15;15583:4;15580:1;15573:15;15599:131;-1:-1:-1;;;;;15674:31:1;;15664:42;;15654:2;;15720:1;15717;15710:12;15654:2;15644:86;:::o

ipfs://bdc3574975eca20f71a7f3642e7230c759494cc45cdb9ed769f0076918d8a080