Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-07-27
*/

// SPDX-License-Identifier: GPL-3.0-or-later
// Sources flattened with hardhat v2.6.1 https://hardhat.org

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

// 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 AddressUpgradeable {
    /**
     * @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 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-upgradeable/proxy/utils/[email protected]

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

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 proxied contracts do not make use of 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.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To initialize the implementation contract, you can either invoke the
 * initializer manually, or you can include a constructor to automatically mark it as initialized when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() initializer {}
 * ```
 * ====
 */
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() {
        // If the contract is initializing we ignore whether _initialized is set in order to support multiple
        // inheritance patterns, but we only do this in the context of a constructor, because in other contexts the
        // contract may have been reentered.
        require(_initializing ? _isConstructor() : !_initialized, "Initializable: contract is already initialized");

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

        _;

        if (isTopLevelCall) {
            _initializing = false;
        }
    }

    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {initializer} modifier, directly or indirectly.
     */
    modifier onlyInitializing() {
        require(_initializing, "Initializable: contract is not initializing");
        _;
    }

    function _isConstructor() private view returns (bool) {
        return !AddressUpgradeable.isContract(address(this));
    }
}


// File interfaces/IGasBank.sol

pragma solidity 0.8.10;

interface IGasBank {
    event Deposit(address indexed account, uint256 value);
    event Withdraw(address indexed account, address indexed receiver, uint256 value);

    function depositFor(address account) external payable;

    function withdrawUnused(address account) external;

    function withdrawFrom(address account, uint256 amount) external;

    function withdrawFrom(
        address account,
        address payable to,
        uint256 amount
    ) external;

    function balanceOf(address account) external view returns (uint256);
}


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

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

pragma solidity ^0.8.0;

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

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

    /**
     * @dev Moves `amount` tokens from the caller's account to `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);

    /**
     * @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 interfaces/strategies/IStrategy.sol

pragma solidity 0.8.10;

interface IStrategy {
    function deposit() external payable returns (bool);

    function withdraw(uint256 amount) external returns (bool);

    function withdrawAll() external returns (uint256);

    function harvest() external returns (uint256);

    function shutdown() external;

    function setCommunityReserve(address _communityReserve) external;

    function setStrategist(address strategist_) external;

    function name() external view returns (string memory);

    function balance() external view returns (uint256);

    function harvestable() external view returns (uint256);

    function strategist() external view returns (address);

    function hasPendingFunds() external view returns (bool);
}


// File interfaces/IVault.sol

pragma solidity 0.8.10;

/**
 * @title Interface for a Vault
 */

interface IVault {
    event StrategyActivated(address indexed strategy);

    event StrategyDeactivated(address indexed strategy);

    /**
     * @dev 'netProfit' is the profit after all fees have been deducted
     */
    event Harvest(uint256 indexed netProfit, uint256 indexed loss);

    function initialize(
        address _pool,
        uint256 _debtLimit,
        uint256 _targetAllocation,
        uint256 _bound
    ) external;

    function withdrawFromStrategyWaitingForRemoval(address strategy) external returns (uint256);

    function deposit() external payable;

    function withdraw(uint256 amount) external returns (bool);

    function withdrawAvailableToPool() external;

    function initializeStrategy(address strategy_) external;

    function shutdownStrategy() external;

    function withdrawFromReserve(uint256 amount) external;

    function updateStrategy(address newStrategy) external;

    function activateStrategy() external returns (bool);

    function deactivateStrategy() external returns (bool);

    function updatePerformanceFee(uint256 newPerformanceFee) external;

    function updateStrategistFee(uint256 newStrategistFee) external;

    function updateDebtLimit(uint256 newDebtLimit) external;

    function updateTargetAllocation(uint256 newTargetAllocation) external;

    function updateReserveFee(uint256 newReserveFee) external;

    function updateBound(uint256 newBound) external;

    function withdrawFromStrategy(uint256 amount) external returns (bool);

    function withdrawAllFromStrategy() external returns (bool);

    function harvest() external returns (bool);

    function getStrategiesWaitingForRemoval() external view returns (address[] memory);

    function getAllocatedToStrategyWaitingForRemoval(address strategy)
        external
        view
        returns (uint256);

    function getTotalUnderlying() external view returns (uint256);

    function getUnderlying() external view returns (address);

    function strategy() external view returns (IStrategy);
}


// File interfaces/pool/ILiquidityPool.sol

pragma solidity 0.8.10;

interface ILiquidityPool {
    event Deposit(address indexed minter, uint256 depositAmount, uint256 mintedLpTokens);

    event DepositFor(
        address indexed minter,
        address indexed mintee,
        uint256 depositAmount,
        uint256 mintedLpTokens
    );

    event Redeem(address indexed redeemer, uint256 redeemAmount, uint256 redeemTokens);

    event LpTokenSet(address indexed lpToken);

    event StakerVaultSet(address indexed stakerVault);

    event Shutdown();

    function redeem(uint256 redeemTokens) external returns (uint256);

    function redeem(uint256 redeemTokens, uint256 minRedeemAmount) external returns (uint256);

    function calcRedeem(address account, uint256 underlyingAmount) external returns (uint256);

    function deposit(uint256 mintAmount) external payable returns (uint256);

    function deposit(uint256 mintAmount, uint256 minTokenAmount) external payable returns (uint256);

    function depositAndStake(uint256 depositAmount, uint256 minTokenAmount)
        external
        payable
        returns (uint256);

    function depositFor(address account, uint256 depositAmount) external payable returns (uint256);

    function depositFor(
        address account,
        uint256 depositAmount,
        uint256 minTokenAmount
    ) external payable returns (uint256);

    function unstakeAndRedeem(uint256 redeemLpTokens, uint256 minRedeemAmount)
        external
        returns (uint256);

    function handleLpTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) external;

    function updateVault(address _vault) external;

    function setLpToken(address _lpToken) external;

    function setStaker() external;

    function shutdownPool(bool shutdownStrategy) external;

    function shutdownStrategy() external;

    function updateRequiredReserves(uint256 _newRatio) external;

    function updateReserveDeviation(uint256 newRatio) external;

    function updateMinWithdrawalFee(uint256 newFee) external;

    function updateMaxWithdrawalFee(uint256 newFee) external;

    function updateWithdrawalFeeDecreasePeriod(uint256 newPeriod) external;

    function rebalanceVault() external;

    function getNewCurrentFees(
        uint256 timeToWait,
        uint256 lastActionTimestamp,
        uint256 feeRatio
    ) external view returns (uint256);

    function vault() external view returns (IVault);

    function getUnderlying() external view returns (address);

    function getLpToken() external view returns (address);

    function getWithdrawalFee(address account, uint256 amount) external view returns (uint256);

    function exchangeRate() external view returns (uint256);

    function totalUnderlying() external view returns (uint256);

    function name() external view returns (string memory);

    function isShutdown() external view returns (bool);
}


// File interfaces/oracles/IOracleProvider.sol

pragma solidity 0.8.10;

interface IOracleProvider {
    /// @notice Checks whether the asset is supported
    /// @param baseAsset the asset of which the price is to be quoted
    /// @return true if the asset is supported
    function isAssetSupported(address baseAsset) external view returns (bool);

    /// @notice Quotes the USD price of `baseAsset`
    /// @param baseAsset the asset of which the price is to be quoted
    /// @return the USD price of the asset
    function getPriceUSD(address baseAsset) external view returns (uint256);

    /// @notice Quotes the ETH price of `baseAsset`
    /// @param baseAsset the asset of which the price is to be quoted
    /// @return the ETH price of the asset
    function getPriceETH(address baseAsset) external view returns (uint256);
}


// File libraries/AddressProviderMeta.sol

pragma solidity 0.8.10;

library AddressProviderMeta {
    struct Meta {
        bool freezable;
        bool frozen;
    }

    function fromUInt(uint256 value) internal pure returns (Meta memory) {
        Meta memory meta;
        meta.freezable = (value & 1) == 1;
        meta.frozen = ((value >> 1) & 1) == 1;
        return meta;
    }

    function toUInt(Meta memory meta) internal pure returns (uint256) {
        uint256 value;
        value |= meta.freezable ? 1 : 0;
        value |= meta.frozen ? 1 << 1 : 0;
        return value;
    }
}


// File interfaces/IAddressProvider.sol

pragma solidity 0.8.10;




// solhint-disable ordering

interface IAddressProvider {
    event KnownAddressKeyAdded(bytes32 indexed key);
    event StakerVaultListed(address indexed stakerVault);
    event StakerVaultDelisted(address indexed stakerVault);
    event ActionListed(address indexed action);
    event PoolListed(address indexed pool);
    event VaultUpdated(address indexed previousVault, address indexed newVault);
    event FeeHandlerAdded(address feeHandler);
    event FeeHandlerRemoved(address feeHandler);

    /** Key functions */
    function getKnownAddressKeys() external view returns (bytes32[] memory);

    function freezeAddress(bytes32 key) external;

    /** Pool functions */

    function allPools() external view returns (address[] memory);

    function addPool(address pool) external;

    function poolsCount() external view returns (uint256);

    function getPoolAtIndex(uint256 index) external view returns (address);

    function isPool(address pool) external view returns (bool);

    function getPoolForToken(address token) external view returns (ILiquidityPool);

    function safeGetPoolForToken(address token) external view returns (address);

    /** Vault functions  */

    function updateVault(address previousVault, address newVault) external;

    function allVaults() external view returns (address[] memory);

    function vaultsCount() external view returns (uint256);

    function getVaultAtIndex(uint256 index) external view returns (address);

    function isVault(address vault) external view returns (bool);

    /** Action functions */

    function allActions() external view returns (address[] memory);

    function addAction(address action) external returns (bool);

    function isAction(address action) external view returns (bool);

    /** Address functions */
    function initializeAddress(bytes32 key, address initialAddress) external;

    function initializeAddress(
        bytes32 key,
        address initialAddress,
        bool frezable
    ) external;

    function initializeAndFreezeAddress(bytes32 key, address initialAddress) external;

    function getAddress(bytes32 key) external view returns (address);

    function getAddress(bytes32 key, bool checkExists) external view returns (address);

    function getAddressMeta(bytes32 key) external view returns (AddressProviderMeta.Meta memory);

    function updateAddress(bytes32 key, address newAddress) external;

    /** Staker vault functions */
    function allStakerVaults() external view returns (address[] memory);

    function tryGetStakerVault(address token) external view returns (bool, address);

    function getStakerVault(address token) external view returns (address);

    function addStakerVault(address stakerVault) external;

    function isStakerVault(address stakerVault, address token) external view returns (bool);

    function isStakerVaultRegistered(address stakerVault) external view returns (bool);

    function isWhiteListedFeeHandler(address feeHandler) external view returns (bool);

    /** Fee Handler function */
    function addFeeHandler(address feeHandler) external;

    function removeFeeHandler(address feeHandler) external;
}


// File interfaces/IStakerVault.sol

pragma solidity 0.8.10;

interface IStakerVault {
    event Staked(address indexed account, uint256 amount);
    event Unstaked(address indexed account, uint256 amount);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

    function initialize(address _token) external;

    function initializeLpGauge(address _lpGauge) external;

    function stake(uint256 amount) external;

    function stakeFor(address account, uint256 amount) external;

    function unstake(uint256 amount) external;

    function unstakeFor(
        address src,
        address dst,
        uint256 amount
    ) external;

    function approve(address spender, uint256 amount) external;

    function transfer(address account, uint256 amount) external;

    function transferFrom(
        address src,
        address dst,
        uint256 amount
    ) external;

    function increaseActionLockedBalance(address account, uint256 amount) external;

    function decreaseActionLockedBalance(address account, uint256 amount) external;

    function updateLpGauge(address _lpGauge) external;

    function poolCheckpoint() external returns (bool);

    function allowance(address owner, address spender) external view returns (uint256);

    function getToken() external view returns (address);

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

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

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

    function getStakedByActions() external view returns (uint256);

    function getPoolTotalStaked() external view returns (uint256);

    function decimals() external view returns (uint8);

    function lpGauge() external view returns (address);
}


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

// OpenZeppelin Contracts v4.4.1 (utils/structs/EnumerableSet.sol)

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastvalue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastvalue;
                // Update the index for the moved value
                set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        return _values(set._inner);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        assembly {
            result := store
        }

        return result;
    }
}


// File libraries/EnumerableMapping.sol

pragma solidity 0.8.10;

library EnumerableMapping {
    using EnumerableSet for EnumerableSet.Bytes32Set;

    // Code take from contracts/utils/structs/EnumerableMap.sol
    // because the helper functions are private

    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Map type with
    // bytes32 keys and values.
    // The Map implementation uses private functions, and user-facing
    // implementations (such as Uint256ToAddressMap) are just wrappers around
    // the underlying Map.
    // This means that we can only create new EnumerableMaps for types that fit
    // in bytes32.

    struct Map {
        // Storage of keys
        EnumerableSet.Bytes32Set _keys;
        mapping(bytes32 => bytes32) _values;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function _set(
        Map storage map,
        bytes32 key,
        bytes32 value
    ) private returns (bool) {
        map._values[key] = value;
        return map._keys.add(key);
    }

    /**
     * @dev Removes a key-value pair from a map. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function _remove(Map storage map, bytes32 key) private returns (bool) {
        delete map._values[key];
        return map._keys.remove(key);
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function _contains(Map storage map, bytes32 key) private view returns (bool) {
        return map._keys.contains(key);
    }

    /**
     * @dev Returns the number of key-value pairs in the map. O(1).
     */
    function _length(Map storage map) private view returns (uint256) {
        return map._keys.length();
    }

    /**
     * @dev Returns the key-value pair stored at position `index` in the map. O(1).
     *
     * Note that there are no guarantees on the ordering of entries inside the
     * array, and it may change when more entries are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Map storage map, uint256 index) private view returns (bytes32, bytes32) {
        bytes32 key = map._keys.at(index);
        return (key, map._values[key]);
    }

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     */
    function _tryGet(Map storage map, bytes32 key) private view returns (bool, bytes32) {
        bytes32 value = map._values[key];
        if (value == bytes32(0)) {
            return (_contains(map, key), bytes32(0));
        } else {
            return (true, value);
        }
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function _get(Map storage map, bytes32 key) private view returns (bytes32) {
        bytes32 value = map._values[key];
        require(value != 0 || _contains(map, key), "EnumerableMap: nonexistent key");
        return value;
    }

    // AddressToAddressMap

    struct AddressToAddressMap {
        Map _inner;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function set(
        AddressToAddressMap storage map,
        address key,
        address value
    ) internal returns (bool) {
        return _set(map._inner, bytes32(uint256(uint160(key))), bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function remove(AddressToAddressMap storage map, address key) internal returns (bool) {
        return _remove(map._inner, bytes32(uint256(uint160(key))));
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function contains(AddressToAddressMap storage map, address key) internal view returns (bool) {
        return _contains(map._inner, bytes32(uint256(uint160(key))));
    }

    /**
     * @dev Returns the number of elements in the map. O(1).
     */
    function length(AddressToAddressMap storage map) internal view returns (uint256) {
        return _length(map._inner);
    }

    /**
     * @dev Returns the element stored at position `index` in the set. O(1).
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressToAddressMap storage map, uint256 index)
        internal
        view
        returns (address, address)
    {
        (bytes32 key, bytes32 value) = _at(map._inner, index);
        return (address(uint160(uint256(key))), address(uint160(uint256(value))));
    }

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     *
     * _Available since v3.4._
     */
    function tryGet(AddressToAddressMap storage map, address key)
        internal
        view
        returns (bool, address)
    {
        (bool success, bytes32 value) = _tryGet(map._inner, bytes32(uint256(uint160(key))));
        return (success, address(uint160(uint256(value))));
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(AddressToAddressMap storage map, address key) internal view returns (address) {
        return address(uint160(uint256(_get(map._inner, bytes32(uint256(uint160(key)))))));
    }

    // AddressToUintMap

    struct AddressToUintMap {
        Map _inner;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function set(
        AddressToUintMap storage map,
        address key,
        uint256 value
    ) internal returns (bool) {
        return _set(map._inner, bytes32(uint256(uint160(key))), bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function remove(AddressToUintMap storage map, address key) internal returns (bool) {
        return _remove(map._inner, bytes32(uint256(uint160(key))));
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function contains(AddressToUintMap storage map, address key) internal view returns (bool) {
        return _contains(map._inner, bytes32(uint256(uint160(key))));
    }

    /**
     * @dev Returns the number of elements in the map. O(1).
     */
    function length(AddressToUintMap storage map) internal view returns (uint256) {
        return _length(map._inner);
    }

    /**
     * @dev Returns the element stored at position `index` in the set. O(1).
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressToUintMap storage map, uint256 index)
        internal
        view
        returns (address, uint256)
    {
        (bytes32 key, bytes32 value) = _at(map._inner, index);
        return (address(uint160(uint256(key))), uint256(value));
    }

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     *
     * _Available since v3.4._
     */
    function tryGet(AddressToUintMap storage map, address key)
        internal
        view
        returns (bool, uint256)
    {
        (bool success, bytes32 value) = _tryGet(map._inner, bytes32(uint256(uint160(key))));
        return (success, uint256(value));
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(AddressToUintMap storage map, address key) internal view returns (uint256) {
        return uint256(_get(map._inner, bytes32(uint256(uint160(key)))));
    }

    // Bytes32ToUIntMap

    struct Bytes32ToUIntMap {
        Map _inner;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function set(
        Bytes32ToUIntMap storage map,
        bytes32 key,
        uint256 value
    ) internal returns (bool) {
        return _set(map._inner, key, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function remove(Bytes32ToUIntMap storage map, bytes32 key) internal returns (bool) {
        return _remove(map._inner, key);
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function contains(Bytes32ToUIntMap storage map, bytes32 key) internal view returns (bool) {
        return _contains(map._inner, key);
    }

    /**
     * @dev Returns the number of elements in the map. O(1).
     */
    function length(Bytes32ToUIntMap storage map) internal view returns (uint256) {
        return _length(map._inner);
    }

    /**
     * @dev Returns the element stored at position `index` in the set. O(1).
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32ToUIntMap storage map, uint256 index)
        internal
        view
        returns (bytes32, uint256)
    {
        (bytes32 key, bytes32 value) = _at(map._inner, index);
        return (key, uint256(value));
    }

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     *
     * _Available since v3.4._
     */
    function tryGet(Bytes32ToUIntMap storage map, bytes32 key)
        internal
        view
        returns (bool, uint256)
    {
        (bool success, bytes32 value) = _tryGet(map._inner, key);
        return (success, uint256(value));
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(Bytes32ToUIntMap storage map, bytes32 key) internal view returns (uint256) {
        return uint256(_get(map._inner, key));
    }
}


// File libraries/EnumerableExtensions.sol

pragma solidity 0.8.10;


library EnumerableExtensions {
    using EnumerableSet for EnumerableSet.AddressSet;
    using EnumerableSet for EnumerableSet.Bytes32Set;
    using EnumerableMapping for EnumerableMapping.AddressToAddressMap;
    using EnumerableMapping for EnumerableMapping.AddressToUintMap;
    using EnumerableMapping for EnumerableMapping.Bytes32ToUIntMap;

    function toArray(EnumerableSet.AddressSet storage addresses)
        internal
        view
        returns (address[] memory)
    {
        uint256 len = addresses.length();
        address[] memory result = new address[](len);
        for (uint256 i; i < len; ) {
            result[i] = addresses.at(i);
            unchecked {
                ++i;
            }
        }
        return result;
    }

    function toArray(EnumerableSet.Bytes32Set storage values)
        internal
        view
        returns (bytes32[] memory)
    {
        uint256 len = values.length();
        bytes32[] memory result = new bytes32[](len);
        for (uint256 i; i < len; ) {
            result[i] = values.at(i);
            unchecked {
                ++i;
            }
        }
        return result;
    }

    function keyAt(EnumerableMapping.AddressToAddressMap storage map, uint256 index)
        internal
        view
        returns (address)
    {
        (address key, ) = map.at(index);
        return key;
    }

    function valueAt(EnumerableMapping.AddressToAddressMap storage map, uint256 index)
        internal
        view
        returns (address)
    {
        (, address value) = map.at(index);
        return value;
    }

    function keyAt(EnumerableMapping.AddressToUintMap storage map, uint256 index)
        internal
        view
        returns (address)
    {
        (address key, ) = map.at(index);
        return key;
    }

    function keyAt(EnumerableMapping.Bytes32ToUIntMap storage map, uint256 index)
        internal
        view
        returns (bytes32)
    {
        (bytes32 key, ) = map.at(index);
        return key;
    }

    function valueAt(EnumerableMapping.AddressToUintMap storage map, uint256 index)
        internal
        view
        returns (uint256)
    {
        (, uint256 value) = map.at(index);
        return value;
    }

    function keysArray(EnumerableMapping.AddressToAddressMap storage map)
        internal
        view
        returns (address[] memory)
    {
        uint256 len = map.length();
        address[] memory result = new address[](len);
        for (uint256 i; i < len; ) {
            result[i] = keyAt(map, i);
            unchecked {
                ++i;
            }
        }
        return result;
    }

    function valuesArray(EnumerableMapping.AddressToAddressMap storage map)
        internal
        view
        returns (address[] memory)
    {
        uint256 len = map.length();
        address[] memory result = new address[](len);
        for (uint256 i; i < len; ) {
            result[i] = valueAt(map, i);
            unchecked {
                ++i;
            }
        }
        return result;
    }

    function keysArray(EnumerableMapping.AddressToUintMap storage map)
        internal
        view
        returns (address[] memory)
    {
        uint256 len = map.length();
        address[] memory result = new address[](len);
        for (uint256 i; i < len; ) {
            result[i] = keyAt(map, i);
            unchecked {
                ++i;
            }
        }
        return result;
    }

    function keysArray(EnumerableMapping.Bytes32ToUIntMap storage map)
        internal
        view
        returns (bytes32[] memory)
    {
        uint256 len = map.length();
        bytes32[] memory result = new bytes32[](len);
        for (uint256 i; i < len; ) {
            result[i] = keyAt(map, i);
            unchecked {
                ++i;
            }
        }
        return result;
    }
}


// File libraries/AddressProviderKeys.sol

pragma solidity 0.8.10;

library AddressProviderKeys {
    bytes32 internal constant _TREASURY_KEY = "treasury";
    bytes32 internal constant _REWARD_HANDLER_KEY = "rewardHandler";
    bytes32 internal constant _GAS_BANK_KEY = "gasBank";
    bytes32 internal constant _VAULT_RESERVE_KEY = "vaultReserve";
    bytes32 internal constant _ORACLE_PROVIDER_KEY = "oracleProvider";
    bytes32 internal constant _POOL_FACTORY_KEY = "poolFactory";
    bytes32 internal constant _CONTROLLER_KEY = "controller";
    bytes32 internal constant _MERO_LOCKER_KEY = "meroLocker";
    bytes32 internal constant _FEE_BURNER_KEY = "feeBurner";
    bytes32 internal constant _ROLE_MANAGER_KEY = "roleManager";
    bytes32 internal constant _SWAPPER_ROUTER_KEY = "swapperRouter";
}


// File libraries/Roles.sol

pragma solidity 0.8.10;

// solhint-disable private-vars-leading-underscore

library Roles {
    bytes32 internal constant GOVERNANCE = "governance";
    bytes32 internal constant ADDRESS_PROVIDER = "address_provider";
    bytes32 internal constant POOL_FACTORY = "pool_factory";
    bytes32 internal constant CONTROLLER = "controller";
    bytes32 internal constant GAUGE_ZAP = "gauge_zap";
    bytes32 internal constant MAINTENANCE = "maintenance";
    bytes32 internal constant INFLATION_MANAGER = "inflation_manager";
    bytes32 internal constant POOL = "pool";
    bytes32 internal constant VAULT = "vault";
}


// File interfaces/IRoleManager.sol

pragma solidity 0.8.10;

interface IRoleManager {
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    function grantRole(bytes32 role, address account) external;

    function addGovernor(address newGovernor) external;

    function renounceGovernance() external;

    function addGaugeZap(address zap) external;

    function removeGaugeZap(address zap) external;

    function revokeRole(bytes32 role, address account) external;

    function hasRole(bytes32 role, address account) external view returns (bool);

    function hasAnyRole(bytes32[] memory roles, address account) external view returns (bool);

    function hasAnyRole(
        bytes32 role1,
        bytes32 role2,
        address account
    ) external view returns (bool);

    function hasAnyRole(
        bytes32 role1,
        bytes32 role2,
        bytes32 role3,
        address account
    ) external view returns (bool);

    function getRoleMemberCount(bytes32 role) external view returns (uint256);

    function getRoleMember(bytes32 role, uint256 index) external view returns (address);
}


// File libraries/Errors.sol

pragma solidity 0.8.10;

// solhint-disable private-vars-leading-underscore

library Error {
    string internal constant ADDRESS_WHITELISTED = "address already whitelisted";
    string internal constant ADMIN_ALREADY_SET = "admin has already been set once";
    string internal constant ADDRESS_NOT_WHITELISTED = "address not whitelisted";
    string internal constant ADDRESS_NOT_FOUND = "address not found";
    string internal constant CONTRACT_INITIALIZED = "contract can only be initialized once";
    string internal constant CONTRACT_PAUSED = "contract is paused";
    string internal constant UNAUTHORIZED_PAUSE = "not authorized to pause";
    string internal constant INVALID_AMOUNT = "invalid amount";
    string internal constant INVALID_INDEX = "invalid index";
    string internal constant INVALID_VALUE = "invalid msg.value";
    string internal constant INVALID_SENDER = "invalid msg.sender";
    string internal constant INVALID_TOKEN = "token address does not match pool's LP token address";
    string internal constant INVALID_DECIMALS = "incorrect number of decimals";
    string internal constant INVALID_ARGUMENT = "invalid argument";
    string internal constant INVALID_PARAMETER_VALUE = "invalid parameter value attempted";
    string internal constant INVALID_IMPLEMENTATION = "invalid pool implementation for given coin";
    string internal constant INVALID_POOL_IMPLEMENTATION =
        "invalid pool implementation for given coin";
    string internal constant INVALID_LP_TOKEN_IMPLEMENTATION =
        "invalid LP Token implementation for given coin";
    string internal constant INVALID_VAULT_IMPLEMENTATION =
        "invalid vault implementation for given coin";
    string internal constant INVALID_STAKER_VAULT_IMPLEMENTATION =
        "invalid stakerVault implementation for given coin";
    string internal constant INSUFFICIENT_ALLOWANCE = "insufficient allowance";
    string internal constant INSUFFICIENT_BALANCE = "insufficient balance";
    string internal constant INSUFFICIENT_AMOUNT_OUT = "Amount received less than min amount";
    string internal constant INSUFFICIENT_AMOUNT_IN = "Amount spent more than max amount";
    string internal constant ADDRESS_ALREADY_SET = "Address is already set";
    string internal constant INSUFFICIENT_STRATEGY_BALANCE = "insufficient strategy balance";
    string internal constant INSUFFICIENT_FUNDS_RECEIVED = "insufficient funds received";
    string internal constant ADDRESS_DOES_NOT_EXIST = "address does not exist";
    string internal constant ADDRESS_FROZEN = "address is frozen";
    string internal constant ROLE_EXISTS = "role already exists";
    string internal constant CANNOT_REVOKE_ROLE = "cannot revoke role";
    string internal constant UNAUTHORIZED_ACCESS = "unauthorized access";
    string internal constant SAME_ADDRESS_NOT_ALLOWED = "same address not allowed";
    string internal constant SELF_TRANSFER_NOT_ALLOWED = "self-transfer not allowed";
    string internal constant ZERO_ADDRESS_NOT_ALLOWED = "zero address not allowed";
    string internal constant ZERO_TRANSFER_NOT_ALLOWED = "zero transfer not allowed";
    string internal constant THRESHOLD_TOO_HIGH = "threshold is too high, must be under 10";
    string internal constant INSUFFICIENT_THRESHOLD = "insufficient threshold";
    string internal constant NO_POSITION_EXISTS = "no position exists";
    string internal constant POSITION_ALREADY_EXISTS = "position already exists";
    string internal constant CANNOT_EXECUTE_IN_SAME_BLOCK = "cannot execute action in same block";
    string internal constant PROTOCOL_NOT_FOUND = "protocol not found";
    string internal constant TOP_UP_FAILED = "top up failed";
    string internal constant SWAP_PATH_NOT_FOUND = "swap path not found";
    string internal constant UNDERLYING_NOT_SUPPORTED = "underlying token not supported";
    string internal constant NOT_ENOUGH_FUNDS_WITHDRAWN =
        "not enough funds were withdrawn from the pool";
    string internal constant FAILED_TRANSFER = "transfer failed";
    string internal constant FAILED_MINT = "mint failed";
    string internal constant FAILED_REPAY_BORROW = "repay borrow failed";
    string internal constant FAILED_METHOD_CALL = "method call failed";
    string internal constant NOTHING_TO_CLAIM = "there is no claimable balance";
    string internal constant ERC20_BALANCE_EXCEEDED = "ERC20: transfer amount exceeds balance";
    string internal constant INVALID_MINTER =
        "the minter address of the LP token and the pool address do not match";
    string internal constant STAKER_VAULT_EXISTS = "a staker vault already exists for the token";
    string internal constant DEADLINE_NOT_ZERO = "deadline must be 0";
    string internal constant NOTHING_PENDING = "no pending change to reset";
    string internal constant DEADLINE_NOT_SET = "deadline is 0";
    string internal constant DEADLINE_NOT_REACHED = "deadline has not been reached yet";
    string internal constant DELAY_TOO_SHORT = "delay must be at least 3 days";
    string internal constant INSUFFICIENT_UPDATE_BALANCE =
        "insufficient funds for updating the position";
    string internal constant SAME_AS_CURRENT = "value must be different to existing value";
    string internal constant NOT_CAPPED = "the pool is not currently capped";
    string internal constant ALREADY_CAPPED = "the pool is already capped";
    string internal constant ALREADY_SHUTDOWN = "the pool is already shutdown";
    string internal constant EXCEEDS_DEPOSIT_CAP = "deposit exceeds deposit cap";
    string internal constant VALUE_TOO_LOW_FOR_GAS = "value too low to cover gas";
    string internal constant NOT_ENOUGH_FUNDS = "not enough funds to withdraw";
    string internal constant ESTIMATED_GAS_TOO_HIGH = "too much ETH will be used for gas";
    string internal constant GAUGE_KILLED = "gauge killed";
    string internal constant INVALID_TARGET = "Invalid Target";
    string internal constant DEPOSIT_FAILED = "deposit failed";
    string internal constant GAS_TOO_HIGH = "too much ETH used for gas";
    string internal constant GAS_BANK_BALANCE_TOO_LOW = "not enough ETH in gas bank to cover gas";
    string internal constant INVALID_TOKEN_TO_ADD = "Invalid token to add";
    string internal constant INVALID_TOKEN_TO_REMOVE = "token can not be removed";
    string internal constant TIME_DELAY_NOT_EXPIRED = "time delay not expired yet";
    string internal constant UNDERLYING_NOT_WITHDRAWABLE =
        "pool does not support additional underlying coins to be withdrawn";
    string internal constant STRATEGY_SHUTDOWN = "Strategy is shutdown";
    string internal constant POOL_SHUTDOWN = "Pool is shutdown";
    string internal constant STRATEGY_DOES_NOT_EXIST = "Strategy does not exist";
    string internal constant GAUGE_STILL_ACTIVE = "Gauge still active";
    string internal constant UNSUPPORTED_UNDERLYING = "Underlying not supported";
    string internal constant NO_DEX_SET = "no dex has been set for token";
    string internal constant INVALID_TOKEN_PAIR = "invalid token pair";
    string internal constant TOKEN_NOT_USABLE = "token not usable for the specific action";
    string internal constant ADDRESS_NOT_ACTION = "address is not registered action";
    string internal constant INVALID_SLIPPAGE_TOLERANCE = "Invalid slippage tolerance";
    string internal constant INVALID_MAX_FEE = "invalid max fee";
    string internal constant POOL_NOT_PAUSED = "Pool must be paused to withdraw from reserve";
    string internal constant INTERACTION_LIMIT = "Max of one deposit and withdraw per block";
    string internal constant GAUGE_EXISTS = "Gauge already exists";
    string internal constant GAUGE_DOES_NOT_EXIST = "Gauge does not exist";
    string internal constant EXCEEDS_MAX_BOOST = "Not allowed to exceed maximum boost on Convex";
    string internal constant PREPARED_WITHDRAWAL =
        "Cannot relock funds when withdrawal is being prepared";
    string internal constant ASSET_NOT_SUPPORTED = "Asset not supported";
    string internal constant STALE_PRICE = "Price is stale";
    string internal constant NEGATIVE_PRICE = "Price is negative";
    string internal constant ROUND_NOT_COMPLETE = "Round not complete";
    string internal constant NOT_ENOUGH_MERO_STAKED = "Not enough MERO tokens staked";
    string internal constant RESERVE_ACCESS_EXCEEDED = "Reserve access exceeded";
}


// File contracts/access/AuthorizationBase.sol

pragma solidity 0.8.10;


/**
 * @notice Provides modifiers for authorization
 */
abstract contract AuthorizationBase {
    /**
     * @notice Only allows a sender with `role` to perform the given action
     */
    modifier onlyRole(bytes32 role) {
        require(_roleManager().hasRole(role, msg.sender), Error.UNAUTHORIZED_ACCESS);
        _;
    }

    /**
     * @notice Only allows a sender with GOVERNANCE role to perform the given action
     */
    modifier onlyGovernance() {
        require(_roleManager().hasRole(Roles.GOVERNANCE, msg.sender), Error.UNAUTHORIZED_ACCESS);
        _;
    }

    /**
     * @notice Only allows a sender with any of `roles` to perform the given action
     */
    modifier onlyRoles2(bytes32 role1, bytes32 role2) {
        require(_roleManager().hasAnyRole(role1, role2, msg.sender), Error.UNAUTHORIZED_ACCESS);
        _;
    }

    /**
     * @notice Only allows a sender with any of `roles` to perform the given action
     */
    modifier onlyRoles3(
        bytes32 role1,
        bytes32 role2,
        bytes32 role3
    ) {
        require(
            _roleManager().hasAnyRole(role1, role2, role3, msg.sender),
            Error.UNAUTHORIZED_ACCESS
        );
        _;
    }

    function roleManager() external view virtual returns (IRoleManager) {
        return _roleManager();
    }

    function _roleManager() internal view virtual returns (IRoleManager);
}


// File contracts/AddressProvider.sol

pragma solidity 0.8.10;








// solhint-disable ordering

contract AddressProvider is IAddressProvider, AuthorizationBase, Initializable {
    using EnumerableMapping for EnumerableMapping.AddressToAddressMap;
    using EnumerableMapping for EnumerableMapping.Bytes32ToUIntMap;
    using EnumerableSet for EnumerableSet.AddressSet;
    using EnumerableSet for EnumerableSet.Bytes32Set;
    using EnumerableExtensions for EnumerableSet.AddressSet;
    using EnumerableExtensions for EnumerableSet.Bytes32Set;
    using EnumerableExtensions for EnumerableMapping.AddressToAddressMap;
    using EnumerableExtensions for EnumerableMapping.Bytes32ToUIntMap;
    using AddressProviderMeta for AddressProviderMeta.Meta;

    mapping(bytes32 => address) public currentAddresses;

    // LpToken -> stakerVault
    EnumerableMapping.AddressToAddressMap internal _stakerVaults;

    EnumerableSet.AddressSet internal _whiteListedFeeHandlers;

    // value is encoded as (bool freezable, bool frozen)
    EnumerableMapping.Bytes32ToUIntMap internal _addressKeyMetas;

    EnumerableSet.AddressSet internal _actions; // list of all actions ever registered

    EnumerableSet.AddressSet internal _vaults; // list of all active vaults

    EnumerableMapping.AddressToAddressMap internal _tokenToPools;

    event AddressUpdated(bytes32 key, address newAddress);

    constructor(address treasury_) {
        AddressProviderMeta.Meta memory meta = AddressProviderMeta.Meta(true, false);
        _addressKeyMetas.set(AddressProviderKeys._TREASURY_KEY, meta.toUInt());
        currentAddresses[AddressProviderKeys._TREASURY_KEY] = treasury_;
    }

    function initialize(address roleManager_) external initializer {
        AddressProviderMeta.Meta memory meta = AddressProviderMeta.Meta(true, true);
        _addressKeyMetas.set(AddressProviderKeys._ROLE_MANAGER_KEY, meta.toUInt());
        currentAddresses[AddressProviderKeys._ROLE_MANAGER_KEY] = roleManager_;
    }

    function getKnownAddressKeys() external view override returns (bytes32[] memory) {
        return _addressKeyMetas.keysArray();
    }

    function addFeeHandler(address feeHandler) external override onlyGovernance {
        require(!_whiteListedFeeHandlers.contains(feeHandler), Error.ADDRESS_WHITELISTED);
        _whiteListedFeeHandlers.add(feeHandler);
        emit FeeHandlerAdded(feeHandler);
    }

    function removeFeeHandler(address feeHandler) external override onlyGovernance {
        require(_whiteListedFeeHandlers.contains(feeHandler), Error.ADDRESS_NOT_WHITELISTED);
        _whiteListedFeeHandlers.remove(feeHandler);
        emit FeeHandlerRemoved(feeHandler);
    }

    /**
     * @notice Adds action.
     * @param action Address of action to add.
     */
    function addAction(address action) external override onlyGovernance returns (bool) {
        bool result = _actions.add(action);
        if (result) {
            emit ActionListed(action);
        }
        return result;
    }

    /**
     * @notice Adds pool.
     * @param pool Address of pool to add.
     */
    function addPool(address pool)
        external
        override
        onlyRoles2(Roles.POOL_FACTORY, Roles.GOVERNANCE)
    {
        require(pool != address(0), Error.ZERO_ADDRESS_NOT_ALLOWED);

        ILiquidityPool ipool = ILiquidityPool(pool);
        address poolToken = ipool.getLpToken();
        require(poolToken != address(0), Error.ZERO_ADDRESS_NOT_ALLOWED);
        if (_tokenToPools.set(poolToken, pool)) {
            address vault = address(ipool.vault());
            if (vault != address(0)) {
                _vaults.add(vault);
            }
            emit PoolListed(pool);
        }
    }

    /** Vault functions  */

    /**
     * @notice returns all the registered vaults
     */
    function allVaults() external view override returns (address[] memory) {
        return _vaults.toArray();
    }

    /**
     * @notice returns the vault at the given index
     */
    function getVaultAtIndex(uint256 index) external view override returns (address) {
        return _vaults.at(index);
    }

    /**
     * @notice returns the number of vaults
     */
    function vaultsCount() external view override returns (uint256) {
        return _vaults.length();
    }

    function isVault(address vault) external view override returns (bool) {
        return _vaults.contains(vault);
    }

    function updateVault(address previousVault, address newVault)
        external
        override
        onlyRole(Roles.POOL)
    {
        if (previousVault != address(0)) {
            _vaults.remove(previousVault);
        }
        if (newVault != address(0)) {
            _vaults.add(newVault);
        }
        emit VaultUpdated(previousVault, newVault);
    }

    /**
     * @notice Returns the address for the given key
     */
    function getAddress(bytes32 key) public view override returns (address) {
        require(_addressKeyMetas.contains(key), Error.ADDRESS_DOES_NOT_EXIST);
        return currentAddresses[key];
    }

    /**
     * @notice Returns the address for the given key
     * @dev if `checkExists` is true, it will fail if the key does not exist
     */
    function getAddress(bytes32 key, bool checkExists) public view override returns (address) {
        require(!checkExists || _addressKeyMetas.contains(key), Error.ADDRESS_DOES_NOT_EXIST);
        return currentAddresses[key];
    }

    /**
     * @notice returns the address metadata for the given key
     */
    function getAddressMeta(bytes32 key)
        public
        view
        override
        returns (AddressProviderMeta.Meta memory)
    {
        (bool exists, uint256 metadata) = _addressKeyMetas.tryGet(key);
        require(exists, Error.ADDRESS_DOES_NOT_EXIST);
        return AddressProviderMeta.fromUInt(metadata);
    }

    function initializeAddress(bytes32 key, address initialAddress) external override {
        initializeAddress(key, initialAddress, false);
    }

    /**
     * @notice Initializes an address
     * @param key Key to initialize
     * @param initialAddress Address for `key`
     */
    function initializeAddress(
        bytes32 key,
        address initialAddress,
        bool freezable
    ) public override onlyGovernance {
        AddressProviderMeta.Meta memory meta = AddressProviderMeta.Meta(freezable, false);
        _initializeAddress(key, initialAddress, meta);
    }

    /**
     * @notice Initializes and freezes address
     * @param key Key to initialize
     * @param initialAddress Address for `key`
     */
    function initializeAndFreezeAddress(bytes32 key, address initialAddress)
        external
        override
        onlyGovernance
    {
        AddressProviderMeta.Meta memory meta = AddressProviderMeta.Meta(true, true);
        _initializeAddress(key, initialAddress, meta);
    }

    /**
     * @notice Freezes a configuration key, making it immutable
     * @param key Key to freeze
     */
    function freezeAddress(bytes32 key) external override onlyGovernance {
        AddressProviderMeta.Meta memory meta = getAddressMeta(key);
        require(!meta.frozen, Error.ADDRESS_FROZEN);
        require(meta.freezable, Error.INVALID_ARGUMENT);
        meta.frozen = true;
        _addressKeyMetas.set(key, meta.toUInt());
    }

    /**
     * @notice Update an address
     * @param key Key to update
     * @param newAddress New address for `key`
     */
    function updateAddress(bytes32 key, address newAddress) external override onlyGovernance {
        _updateAddress(key, newAddress);
        emit AddressUpdated(key, newAddress);
    }

    /**
     * @notice Add a new staker vault.
     * @dev This fails if the token of the staker vault is the token of an existing staker vault.
     * @param stakerVault Vault to add.
     */
    function addStakerVault(address stakerVault) external override onlyRole(Roles.CONTROLLER) {
        address token = IStakerVault(stakerVault).getToken();
        require(token != address(0), Error.ZERO_ADDRESS_NOT_ALLOWED);
        require(!_stakerVaults.contains(token), Error.STAKER_VAULT_EXISTS);
        _stakerVaults.set(token, stakerVault);
        emit StakerVaultListed(stakerVault);
    }

    function isWhiteListedFeeHandler(address feeHandler) external view override returns (bool) {
        return _whiteListedFeeHandlers.contains(feeHandler);
    }

    /**
     * @notice Get the liquidity pool for a given token
     * @dev Does not revert if the pool does not exist
     * @param token Token for which to get the pool.
     * @return Pool address.
     */
    function safeGetPoolForToken(address token) external view override returns (address) {
        (, address poolAddress) = _tokenToPools.tryGet(token);
        return poolAddress;
    }

    /**
     * @notice Get the liquidity pool for a given token
     * @dev Reverts if the pool does not exist
     * @param token Token for which to get the pool.
     * @return Pool address.
     */
    function getPoolForToken(address token) external view override returns (ILiquidityPool) {
        (bool exists, address poolAddress) = _tokenToPools.tryGet(token);
        require(exists, Error.ADDRESS_NOT_FOUND);
        return ILiquidityPool(poolAddress);
    }

    /**
     * @notice Get list of all action addresses.
     * @return Array with action addresses.
     */
    function allActions() external view override returns (address[] memory) {
        return _actions.toArray();
    }

    /**
     * @notice Check whether an address is an action.
     * @param action Address to check whether it is action.
     * @return True if address is an action.
     */
    function isAction(address action) external view override returns (bool) {
        return _actions.contains(action);
    }

    /**
     * @notice Check whether an address is a pool.
     * @param pool Address to check whether it is a pool.
     * @return True if address is a pool.
     */
    function isPool(address pool) external view override returns (bool) {
        address lpToken = ILiquidityPool(pool).getLpToken();
        (bool exists, address poolAddress) = _tokenToPools.tryGet(lpToken);
        return exists && pool == poolAddress;
    }

    /**
     * @notice Get list of all pool addresses.
     * @return Array with pool addresses.
     */
    function allPools() external view override returns (address[] memory) {
        return _tokenToPools.valuesArray();
    }

    /**
     * @notice returns the pool at the given index
     */
    function getPoolAtIndex(uint256 index) external view override returns (address) {
        return _tokenToPools.valueAt(index);
    }

    /**
     * @notice returns the number of pools
     */
    function poolsCount() external view override returns (uint256) {
        return _tokenToPools.length();
    }

    /**
     * @notice Returns all the staker vaults.
     */
    function allStakerVaults() external view override returns (address[] memory) {
        return _stakerVaults.valuesArray();
    }

    /**
     * @notice Get the staker vault for a given token
     * @dev There can only exist one staker vault per unique token.
     * @param token Token for which to get the vault.
     * @return Vault address.
     */
    function getStakerVault(address token) external view override returns (address) {
        return _stakerVaults.get(token);
    }

    /**
     * @notice Tries to get the staker vault for a given token but does not throw if it does not exist
     * @return A boolean set to true if the vault exists and the vault address.
     */
    function tryGetStakerVault(address token) external view override returns (bool, address) {
        return _stakerVaults.tryGet(token);
    }

    /**
     * @notice Check if a vault is registered (exists).
     * @param stakerVault Address of staker vault to check.
     * @return `true` if registered, `false` if not.
     */
    function isStakerVaultRegistered(address stakerVault) external view override returns (bool) {
        address token = IStakerVault(stakerVault).getToken();
        return isStakerVault(stakerVault, token);
    }

    function isStakerVault(address stakerVault, address token) public view override returns (bool) {
        (bool exists, address vault) = _stakerVaults.tryGet(token);
        return exists && vault == stakerVault;
    }

    function _updateAddress(bytes32 key, address newAddress) internal {
        AddressProviderMeta.Meta memory meta = getAddressMeta(key);
        require(!meta.frozen, Error.ADDRESS_FROZEN);
        if (newAddress == address(0)) {
            delete currentAddresses[key];
            return;
        }
        currentAddresses[key] = newAddress;
    }

    function _roleManager() internal view override returns (IRoleManager) {
        return IRoleManager(getAddress(AddressProviderKeys._ROLE_MANAGER_KEY));
    }

    function _initializeAddress(
        bytes32 key,
        address initialAddress,
        AddressProviderMeta.Meta memory meta
    ) internal {
        require(!_addressKeyMetas.contains(key), Error.INVALID_ARGUMENT);
        _addKnownAddressKey(key, meta);
        currentAddresses[key] = initialAddress;
    }

    function _addKnownAddressKey(bytes32 key, AddressProviderMeta.Meta memory meta) internal {
        require(_addressKeyMetas.set(key, meta.toUInt()), Error.INVALID_ARGUMENT);
        emit KnownAddressKeyAdded(key);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"treasury_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"action","type":"address"}],"name":"ActionListed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"key","type":"bytes32"},{"indexed":false,"internalType":"address","name":"newAddress","type":"address"}],"name":"AddressUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"feeHandler","type":"address"}],"name":"FeeHandlerAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"feeHandler","type":"address"}],"name":"FeeHandlerRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"key","type":"bytes32"}],"name":"KnownAddressKeyAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pool","type":"address"}],"name":"PoolListed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"stakerVault","type":"address"}],"name":"StakerVaultDelisted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"stakerVault","type":"address"}],"name":"StakerVaultListed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousVault","type":"address"},{"indexed":true,"internalType":"address","name":"newVault","type":"address"}],"name":"VaultUpdated","type":"event"},{"inputs":[{"internalType":"address","name":"action","type":"address"}],"name":"addAction","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"feeHandler","type":"address"}],"name":"addFeeHandler","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pool","type":"address"}],"name":"addPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"stakerVault","type":"address"}],"name":"addStakerVault","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"allActions","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"allPools","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"allStakerVaults","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"allVaults","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"currentAddresses","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"key","type":"bytes32"}],"name":"freezeAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"key","type":"bytes32"}],"name":"getAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"key","type":"bytes32"},{"internalType":"bool","name":"checkExists","type":"bool"}],"name":"getAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"key","type":"bytes32"}],"name":"getAddressMeta","outputs":[{"components":[{"internalType":"bool","name":"freezable","type":"bool"},{"internalType":"bool","name":"frozen","type":"bool"}],"internalType":"struct AddressProviderMeta.Meta","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getKnownAddressKeys","outputs":[{"internalType":"bytes32[]","name":"","type":"bytes32[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getPoolAtIndex","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"getPoolForToken","outputs":[{"internalType":"contract ILiquidityPool","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"getStakerVault","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getVaultAtIndex","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"roleManager_","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"key","type":"bytes32"},{"internalType":"address","name":"initialAddress","type":"address"},{"internalType":"bool","name":"freezable","type":"bool"}],"name":"initializeAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"key","type":"bytes32"},{"internalType":"address","name":"initialAddress","type":"address"}],"name":"initializeAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"key","type":"bytes32"},{"internalType":"address","name":"initialAddress","type":"address"}],"name":"initializeAndFreezeAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"action","type":"address"}],"name":"isAction","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pool","type":"address"}],"name":"isPool","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"stakerVault","type":"address"},{"internalType":"address","name":"token","type":"address"}],"name":"isStakerVault","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"stakerVault","type":"address"}],"name":"isStakerVaultRegistered","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"vault","type":"address"}],"name":"isVault","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"feeHandler","type":"address"}],"name":"isWhiteListedFeeHandler","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolsCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"feeHandler","type":"address"}],"name":"removeFeeHandler","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"roleManager","outputs":[{"internalType":"contract IRoleManager","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"safeGetPoolForToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"tryGetStakerVault","outputs":[{"internalType":"bool","name":"","type":"bool"},{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"key","type":"bytes32"},{"internalType":"address","name":"newAddress","type":"address"}],"name":"updateAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"previousVault","type":"address"},{"internalType":"address","name":"newVault","type":"address"}],"name":"updateVault","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"vaultsCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

0000000000000000000000008ca8f797506bba85ad418dd2eb190da561d37641

-----Decoded View---------------
Arg [0] : treasury_ (address): 0x8Ca8f797506BBA85AD418dD2eb190Da561D37641

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000008ca8f797506bba85ad418dd2eb190da561d37641

68583:13705:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68276:108;;;:::i;:::-;;;-1:-1:-1;;;;;199:32:1;;;181:51;;169:2;154:18;68276:108:0;;;;;;;;72399:114;;;:::i;:::-;;;;;;;:::i;72592:124::-;;;;;;:::i;:::-;;:::i;79318:134::-;;;;;;:::i;:::-;;:::i;75264:288::-;;;;;;:::i;:::-;;:::i;:::-;;73028:379;;;;;;:::i;:::-;;:::i;73487:199::-;;;;;;:::i;:::-;;:::i;71330:234::-;;;;;;:::i;:::-;;:::i;:::-;;;2750:14:1;;2743:22;2725:41;;2713:2;2698:18;71330:234:0;2585:187:1;77743:267:0;;;;;;:::i;:::-;;:::i;80753:214::-;;;;;;:::i;:::-;;:::i;76155:186::-;;;;;;:::i;:::-;;:::i;80072:130::-;;;;;;:::i;:::-;;:::i;78738:262::-;;;;;;:::i;:::-;;:::i;78131:116::-;;;:::i;78435:123::-;;;;;;:::i;:::-;;:::i;72901:119::-;;;;;;:::i;:::-;;:::i;70670:269::-;;;;;;:::i;:::-;;:::i;80413:142::-;;;;;;:::i;:::-;;:::i;:::-;;;;3200:14:1;;3193:22;3175:41;;-1:-1:-1;;;;;3252:32:1;;;3247:2;3232:18;;3225:60;3148:18;80413:142:0;3007:284:1;74804:301:0;;;;;;:::i;:::-;;:::i;79706:130::-;;;:::i;74166:334::-;;;;;;:::i;:::-;;:::i;:::-;;;;4094:13:1;;4087:21;4080:29;4062:48;;4180:4;4168:17;;;4162:24;4155:32;4148:40;4126:20;;;4119:70;;;;4035:18;74166:334:0;3874:321:1;70527:135:0;;;:::i;:::-;;;;;;;:::i;76958:161::-;;;;;;:::i;:::-;;:::i;72787:106::-;;;:::i;:::-;;;4983:25:1;;;4971:2;4956:18;72787:106:0;4837:177:1;74508:146:0;;;;;;:::i;:::-;;:::i;79522:111::-;;;:::i;80975:220::-;;;;;;:::i;:::-;;:::i;76547:403::-;;;;;;:::i;:::-;;:::i;70196:323::-;;;;;;:::i;:::-;;:::i;79117:123::-;;;:::i;70947:280::-;;;;;;:::i;:::-;;:::i;71661:631::-;;;;;;:::i;:::-;;:::i;73844:233::-;;;;;;:::i;:::-;;:::i;75676:338::-;;;;;;:::i;:::-;;:::i;69254:51::-;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;69254:51:0;;;77342:186;;;;;;:::i;:::-;;:::i;68276:108::-;68330:12;68362:14;:12;:14::i;:::-;68355:21;;68276:108;:::o;72399:114::-;72452:16;72488:17;:7;:15;:17::i;72592:124::-;72664:7;72691:17;:7;72702:5;72691:10;:17::i;:::-;72684:24;72592:124;-1:-1:-1;;72592:124:0:o;79318:134::-;79389:7;79416:28;:13;79438:5;79416:21;:28::i;75264:288::-;67517:14;:12;:14::i;:::-;:52;;-1:-1:-1;;;67517:52:0;;-1:-1:-1;;;67517:52:0;;;5507:25:1;67558:10:0;5548:18:1;;;5541:60;-1:-1:-1;;;;;67517:22:0;;;;;;;5480:18:1;;67517:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;67571:25;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;67571:25:0;;;67509:88;;;;;-1:-1:-1;;;67509:88:0;;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;75452:36:0::1;::::0;;;;::::1;::::0;;;75477:4:::1;75452:36:::0;;;::::1;::::0;::::1;::::0;75499:45:::1;75518:3:::0;75523:14;75452:36;75499:18:::1;:45::i;:::-;75402:150;75264:288:::0;;:::o;73028:379::-;-1:-1:-1;;;67272:14:0;:12;:14::i;:::-;:40;;-1:-1:-1;;;67272:40:0;;;;;5507:25:1;;;67301:10:0;5548:18:1;;;5541:60;-1:-1:-1;;;;;67272:22:0;;;;;;;5480:18:1;;67272:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;67314:25;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;67314:25:0;;;67264:76;;;;;-1:-1:-1;;;67264:76:0;;;;;;;;:::i;:::-;-1:-1:-1;;;;;;73176:27:0;::::1;::::0;73172:89:::1;;73220:29;:7;73235:13:::0;73220:14:::1;:29::i;:::-;;73172:89;-1:-1:-1::0;;;;;73275:22:0;::::1;::::0;73271:76:::1;;73314:21;:7;73326:8:::0;73314:11:::1;:21::i;:::-;;73271:76;73390:8;-1:-1:-1::0;;;;;73362:37:0::1;73375:13;-1:-1:-1::0;;;;;73362:37:0::1;;;;;;;;;;;73028:379:::0;;;:::o;73487:199::-;73550:7;73578:30;:16;73604:3;73578:25;:30::i;:::-;73610:28;;;;;;;;;;;;;-1:-1:-1;;;73610:28:0;;;73570:69;;;;;-1:-1:-1;;;73570:69:0;;;;;;;;:::i;:::-;-1:-1:-1;;73657:21:0;;;;:16;:21;;;;;;-1:-1:-1;;;;;73657:21:0;;73487:199::o;71330:234::-;71407:4;67517:14;:12;:14::i;:::-;:52;;-1:-1:-1;;;67517:52:0;;-1:-1:-1;;;67517:52:0;;;5507:25:1;67558:10:0;5548:18:1;;;5541:60;-1:-1:-1;;;;;67517:22:0;;;;;;;5480:18:1;;67517:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;67571:25;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;67571:25:0;;;67509:88;;;;;-1:-1:-1;;;67509:88:0;;;;;;;;:::i;:::-;-1:-1:-1;71424:11:0::1;71438:20;:8;71451:6:::0;71438:12:::1;:20::i;:::-;71424:34;;71473:6;71469:64;;;71501:20;::::0;-1:-1:-1;;;;;71501:20:0;::::1;::::0;::::1;::::0;;;::::1;71550:6:::0;71330:234;-1:-1:-1;;71330:234:0:o;77743:267::-;77815:14;;;77879:27;:13;77900:5;77879:20;:27::i;:::-;77842:64;;;;77925:6;77933:23;;;;;;;;;;;;;-1:-1:-1;;;77933:23:0;;;77917:40;;;;;-1:-1:-1;;;77917:40:0;;;;;;;;:::i;:::-;-1:-1:-1;77990:11:0;77743:267;-1:-1:-1;;;77743:267:0:o;80753:214::-;80839:4;80856:13;80885:11;-1:-1:-1;;;;;80872:34:0;;:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;80856:52;;80926:33;80940:11;80953:5;80926:13;:33::i;:::-;80919:40;80753:214;-1:-1:-1;;;80753:214:0:o;76155:186::-;67517:14;:12;:14::i;:::-;:52;;-1:-1:-1;;;67517:52:0;;-1:-1:-1;;;67517:52:0;;;5507:25:1;67558:10:0;5548:18:1;;;5541:60;-1:-1:-1;;;;;67517:22:0;;;;;;;5480:18:1;;67517:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;67571:25;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;67571:25:0;;;67509:88;;;;;-1:-1:-1;;;67509:88:0;;;;;;;;:::i;:::-;;76255:31:::1;76270:3;76275:10;76255:14;:31::i;:::-;76302;::::0;;5507:25:1;;;-1:-1:-1;;;;;5568:32:1;;5563:2;5548:18;;5541:60;76302:31:0::1;::::0;5480:18:1;76302:31:0::1;;;;;;;76155:186:::0;;:::o;80072:130::-;80143:7;80170:24;:13;80188:5;80170:17;:24::i;78738:262::-;78800:4;78817:15;78850:4;-1:-1:-1;;;;;78835:31:0;;:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;78817:51;-1:-1:-1;78880:11:0;;78916:29;:13;78817:51;78916:20;:29::i;:::-;78879:66;;;;78963:6;:29;;;;;78981:11;-1:-1:-1;;;;;78973:19:0;:4;-1:-1:-1;;;;;78973:19:0;;78963:29;78956:36;78738:262;-1:-1:-1;;;;;78738:262:0:o;78131:116::-;78185:16;78221:18;:8;:16;:18::i;78435:123::-;78501:4;78525:25;:8;78543:6;78525:17;:25::i;72901:119::-;72965:4;72989:23;:7;73006:5;72989:16;:23::i;70670:269::-;67517:14;:12;:14::i;:::-;:52;;-1:-1:-1;;;67517:52:0;;-1:-1:-1;;;67517:52:0;;;5507:25:1;67558:10:0;5548:18:1;;;5541:60;-1:-1:-1;;;;;67517:22:0;;;;;;;5480:18:1;;67517:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;67571:25;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;67571:25:0;;;67509:88;;;;;-1:-1:-1;;;67509:88:0;;;;;;;;:::i;:::-;-1:-1:-1;70766:44:0::1;:23;70799:10:::0;70766:32:::1;:44::i;:::-;70765:45;70812:25;;;;;;;;;;;;;;;;::::0;70757:81:::1;;;;;-1:-1:-1::0;;;70757:81:0::1;;;;;;;;:::i;:::-;-1:-1:-1::0;70849:39:0::1;:23;70877:10:::0;70849:27:::1;:39::i;:::-;-1:-1:-1::0;70904:27:0::1;::::0;-1:-1:-1;;;;;199:32:1;;181:51;;70904:27:0::1;::::0;169:2:1;154:18;70904:27:0::1;;;;;;;;70670:269:::0;:::o;80413:142::-;80487:4;;80520:27;:13;80541:5;80520:20;:27::i;:::-;80513:34;;;;80413:142;;;:::o;74804:301::-;67517:14;:12;:14::i;:::-;:52;;-1:-1:-1;;;67517:52:0;;-1:-1:-1;;;67517:52:0;;;5507:25:1;67558:10:0;5548:18:1;;;5541:60;-1:-1:-1;;;;;67517:22:0;;;;;;;5480:18:1;;67517:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;67571:25;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;67571:25:0;;;67509:88;;;;;-1:-1:-1;;;67509:88:0;;;;;;;;:::i;:::-;-1:-1:-1;74999:42:0::1;::::0;;;;::::1;::::0;;;;::::1;;::::0;;74960:36:::1;74999:42;::::0;::::1;::::0;75052:45:::1;75071:3:::0;75076:14;74999:42;75052:18:::1;:45::i;:::-;74949:156;74804:301:::0;;;:::o;79706:130::-;79765:16;79801:27;:13;:25;:27::i;74166:334::-;-1:-1:-1;;;;;;;;;;;;;;;;;74319:11:0;;74352:28;:16;74376:3;74352:23;:28::i;:::-;74318:62;;;;74399:6;74407:28;;;;;;;;;;;;;-1:-1:-1;;;74407:28:0;;;74391:45;;;;;-1:-1:-1;;;74391:45:0;;;;;;;;:::i;:::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;21694:1:0;21686:9;;;21685:16;;21668:33;;21728:10;;;21727:16;;21726:23;-1:-1:-1;;;21712:37:0;74454:38;74447:45;74166:334;-1:-1:-1;;;;74166:334:0:o;70527:135::-;70590:16;70626:28;:16;:26;:28::i;76958:161::-;77043:4;77067:44;:23;77100:10;77067:32;:44::i;72787:106::-;72842:7;72869:16;:7;:14;:16::i;74508:146::-;74601:45;74619:3;74624:14;74640:5;74601:17;:45::i;:::-;74508:146;;:::o;79522:111::-;79576:7;79603:22;:13;:20;:22::i;80975:220::-;81064:4;;;81112:27;:13;81133:5;81112:20;:27::i;:::-;81081:58;;;;81157:6;:30;;;;;81176:11;-1:-1:-1;;;;;81167:20:0;:5;-1:-1:-1;;;;;81167:20:0;;81150:37;80975:220;-1:-1:-1;;;;;80975:220:0:o;76547:403::-;-1:-1:-1;;;67272:14:0;:12;:14::i;:::-;:40;;-1:-1:-1;;;67272:40:0;;;;;5507:25:1;;;67301:10:0;5548:18:1;;;5541:60;-1:-1:-1;;;;;67272:22:0;;;;;;;5480:18:1;;67272:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;67314:25;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;67314:25:0;;;67264:76;;;;;-1:-1:-1;;;67264:76:0;;;;;;;;:::i;:::-;;76648:13:::1;76677:11;-1:-1:-1::0;;;;;76664:34:0::1;;:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;76740:30;::::0;;;;::::1;::::0;;;::::1;::::0;;-1:-1:-1;;;76740:30:0::1;::::0;::::1;::::0;76648:52;;-1:-1:-1;;;;;;76719:19:0;::::1;76711:60;;;;-1:-1:-1::0;;;76711:60:0::1;;;;;;;;:::i;:::-;-1:-1:-1::0;76791:29:0::1;:13;76814:5:::0;76791:22:::1;:29::i;:::-;76790:30;76822:25;;;;;;;;;;;;;;;;;76782:66;;;;;-1:-1:-1::0;;;76782:66:0::1;;;;;;;;:::i;:::-;-1:-1:-1::0;76859:37:0::1;:13;76877:5:::0;76884:11;76859:17:::1;:37::i;:::-;-1:-1:-1::0;76912:30:0::1;::::0;-1:-1:-1;;;;;76912:30:0;::::1;::::0;::::1;::::0;;;::::1;76637:313;76547:403:::0;;:::o;70196:323::-;10100:13;;;;;;;:48;;10136:12;;;;10135:13;10100:48;;;10903:4;1676:19;:23;10116:16;10092:107;;;;-1:-1:-1;;;10092:107:0;;6922:2:1;10092:107:0;;;6904:21:1;6961:2;6941:18;;;6934:30;7000:34;6980:18;;;6973:62;-1:-1:-1;;;7051:18:1;;;7044:44;7105:19;;10092:107:0;6720:410:1;10092:107:0;10212:19;10235:13;;;;;;10234:14;10259:101;;;;10294:13;:20;;-1:-1:-1;;10329:19:0;;;;;10259:101;70309:36:::1;::::0;;;;::::1;::::0;;;70334:4:::1;70309:36:::0;;;::::1;::::0;::::1;::::0;70356:74:::1;-1:-1:-1::0;;;70416:13:0::1;70309:36:::0;70416:11:::1;:13::i;:::-;70356:16;::::0;:74;:20:::1;:74::i;:::-;-1:-1:-1::0;;;;;70441:55:0::1;::::0;:16:::1;:55;::::0;;:70;;-1:-1:-1;;;;;;70441:70:0::1;-1:-1:-1::0;;;;;70441:70:0;::::1;;::::0;;10386:68;;;;10437:5;10421:21;;-1:-1:-1;;10421:21:0;;;9807:654;70196:323;:::o;79117:123::-;79169:16;79205:27;:13;:25;:27::i;70947:280::-;67517:14;:12;:14::i;:::-;:52;;-1:-1:-1;;;67517:52:0;;-1:-1:-1;;;67517:52:0;;;5507:25:1;67558:10:0;5548:18:1;;;5541:60;-1:-1:-1;;;;;67517:22:0;;;;;;;5480:18:1;;67517:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;67571:25;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;67571:25:0;;;67509:88;;;;;-1:-1:-1;;;67509:88:0;;;;;;;;:::i;:::-;-1:-1:-1;71045:44:0::1;:23;71078:10:::0;71045:32:::1;:44::i;:::-;71091:29;;;;;;;;;;;;;;;;::::0;71037:84:::1;;;;;-1:-1:-1::0;;;71037:84:0::1;;;;;;;;:::i;:::-;-1:-1:-1::0;71132:42:0::1;:23;71163:10:::0;71132:30:::1;:42::i;:::-;-1:-1:-1::0;71190:29:0::1;::::0;-1:-1:-1;;;;;199:32:1;;181:51;;71190:29:0::1;::::0;169:2:1;154:18;71190:29:0::1;14:224:1::0;71661:631:0;-1:-1:-1;;;;;;67797:14:0;:12;:14::i;:::-;:51;;-1:-1:-1;;;67797:51:0;;;;;7337:25:1;;;7378:18;;;7371:34;;;67837:10:0;7421:18:1;;;7414:60;-1:-1:-1;;;;;67797:25:0;;;;;;;7310:18:1;;67797:51:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;67850:25;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;67850:25:0;;;67789:87;;;;;-1:-1:-1;;;67789:87:0;;;;;;;;:::i;:::-;-1:-1:-1;71830:30:0::1;::::0;;;;::::1;::::0;;;::::1;::::0;;-1:-1:-1;;;71830:30:0::1;::::0;::::1;::::0;-1:-1:-1;;;;;71810:18:0;::::1;71802:59;;;;-1:-1:-1::0;;;71802:59:0::1;;;;;;;;:::i;:::-;;71874:20;71912:4;71874:43;;71928:17;71948:5;-1:-1:-1::0;;;;;71948:16:0::1;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;72010:30;::::0;;;;::::1;::::0;;;::::1;::::0;;-1:-1:-1;;;72010:30:0::1;::::0;::::1;::::0;71928:38;;-1:-1:-1;;;;;;71985:23:0;::::1;71977:64;;;;-1:-1:-1::0;;;71977:64:0::1;;;;;;;;:::i;:::-;-1:-1:-1::0;72056:34:0::1;:13;72074:9:::0;72085:4;72056:17:::1;:34::i;:::-;72052:233;;;72107:13;72131:5;-1:-1:-1::0;;;;;72131:11:0::1;;:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;72107:38:::0;-1:-1:-1;;;;;;72164:19:0;::::1;::::0;72160:78:::1;;72204:18;:7;72216:5:::0;72204:11:::1;:18::i;:::-;;72160:78;72257:16;::::0;-1:-1:-1;;;;;72257:16:0;::::1;::::0;::::1;::::0;;;::::1;72092:193;72052:233;71791:501;;71661:631:::0;;;:::o;73844:233::-;73925:7;73954:11;73953:12;:46;;;-1:-1:-1;73969:30:0;:16;73995:3;73969:25;:30::i;:::-;74001:28;;;;;;;;;;;;;-1:-1:-1;;;74001:28:0;;;73945:85;;;;;-1:-1:-1;;;73945:85:0;;;;;;;;:::i;:::-;-1:-1:-1;;;74048:21:0;;;;:16;:21;;;;;;-1:-1:-1;;;;;74048:21:0;;73844:233::o;75676:338::-;67517:14;:12;:14::i;:::-;:52;;-1:-1:-1;;;67517:52:0;;-1:-1:-1;;;67517:52:0;;;5507:25:1;67558:10:0;5548:18:1;;;5541:60;-1:-1:-1;;;;;67517:22:0;;;;;;;5480:18:1;;67517:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;67571:25;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;67571:25:0;;;67509:88;;;;;-1:-1:-1;;;67509:88:0;;;;;;;;:::i;:::-;;75756:36:::1;75795:19;75810:3;75795:14;:19::i;:::-;75756:58;;75834:4;:11;;;75833:12;75847:20;;;;;;;;;;;;;-1:-1:-1::0;;;75847:20:0::1;;::::0;75825:43:::1;;;;;-1:-1:-1::0;;;75825:43:0::1;;;;;;;;:::i;:::-;-1:-1:-1::0;75887:14:0;;75903:22:::1;::::0;;;;::::1;::::0;;;::::1;::::0;;-1:-1:-1;;;75903:22:0::1;::::0;::::1;::::0;;75879:47:::1;;;;-1:-1:-1::0;;;75879:47:0::1;;;;;;;;:::i;:::-;-1:-1:-1::0;75951:4:0::1;75937:11;::::0;::::1;:18:::0;75966:40:::1;75987:3:::0;75992:13:::1;75937:4:::0;75992:11:::1;:13::i;77342:186::-:0;77418:7;;77464:27;:13;77485:5;77464:20;:27::i;21787:207::-;21844:7;21864:13;21897:4;:14;;;:22;;21918:1;21897:22;;;21914:1;21897:22;21888:31;;;;;;21939:4;:11;;;:24;;21962:1;21939:24;;;21953:6;21939:24;21930:33;;;;21787:207;-1:-1:-1;;21787:207:0:o;49257:192::-;49380:4;49404:37;49409:3;49421;49434:5;49404:4;:37::i;32939:125::-;33009:4;33033:23;33038:3;33050:5;33033:4;:23::i;81569:159::-;81625:12;81670:49;-1:-1:-1;;;81670:10:0;:49::i;51956:417::-;52067:16;52101:11;52115:18;:9;:16;:18::i;:::-;52101:32;;52144:23;52184:3;52170:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;52170:18:0;;52144:44;;52204:9;52199:143;52219:3;52215:1;:7;52199:143;;;52253:15;:9;52266:1;52253:12;:15::i;:::-;52241:6;52248:1;52241:9;;;;;;;;:::i;:::-;-1:-1:-1;;;;;52241:27:0;;;:9;;;;;;;;;;;:27;52312:3;;52199:143;;36511:158;36585:7;36636:22;36640:3;36652:5;36636:3;:22::i;53021:222::-;53154:7;;53199:13;:3;53206:5;53199:6;:13::i;81736:319::-;81902:30;:16;81928:3;81902:25;:30::i;:::-;81901:31;81934:22;;;;;;;;;;;;;-1:-1:-1;;;81934:22:0;;;81893:64;;;;;-1:-1:-1;;;81893:64:0;;;;;;;;:::i;:::-;;81968:30;81988:3;81993:4;81968:19;:30::i;:::-;-1:-1:-1;82009:21:0;;;;:16;:21;;;;;;:38;;-1:-1:-1;;;;;;82009:38:0;-1:-1:-1;;;;;82009:38:0;;;;;;;;;81736:319::o;35543:158::-;35616:4;35640:53;35648:3;-1:-1:-1;;;;;35668:23:0;;35640:7;:53::i;35215:152::-;35285:4;35309:50;35314:3;-1:-1:-1;;;;;35334:23:0;;35309:4;:50::i;49832:142::-;49916:4;49940:26;49950:3;49962;49940:9;:26::i;45542:295::-;45654:4;;;;45717:51;45725:3;-1:-1:-1;;;;;45745:21:0;;45717:7;:51::i;:::-;45685:83;;-1:-1:-1;45685:83:0;-1:-1:-1;;;45542:295:0;;;;;;:::o;81203:358::-;81280:36;81319:19;81334:3;81319:14;:19::i;:::-;81280:58;;81358:4;:11;;;81357:12;81371:20;;;;;;;;;;;;;-1:-1:-1;;;81371:20:0;;;81349:43;;;;;-1:-1:-1;;;81349:43:0;;;;;;;;:::i;:::-;-1:-1:-1;;;;;;81407:24:0;;81403:106;;-1:-1:-1;;81455:21:0;;;;:16;:21;;;;;81448:28;;-1:-1:-1;;;;;;81448:28:0;;;81203:358::o;45998:192::-;46080:7;46131:48;46136:3;-1:-1:-1;;;;;46156:21:0;;46131:4;:48::i;35787:167::-;-1:-1:-1;;;;;35921:23:0;;35867:4;31323:19;;;:12;;;:19;;;;;;:24;;35891:55;31226:129;54346:422;54468:16;54502:11;54516:12;:3;:10;:12::i;:::-;54502:26;;54539:23;54579:3;54565:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;54565:18:0;;54539:44;;54599:9;54594:143;54614:3;54610:1;:7;54594:143;;;54648:15;54656:3;54661:1;54648:7;:15::i;:::-;54636:6;54643:1;54636:9;;;;;;;;:::i;:::-;-1:-1:-1;;;;;54636:27:0;;;:9;;;;;;;;;;;:27;54707:3;;54594:143;;50962:247;51071:4;;;;51134:24;51142:3;51154;51134:7;:24::i;55199:415::-;55316:16;55350:11;55364:12;:3;:10;:12::i;:::-;55350:26;;55387:23;55427:3;55413:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;55413:18:0;;55387:44;;55447:9;55442:141;55462:3;55458:1;:7;55442:141;;;55496:13;55502:3;55507:1;55496:5;:13::i;:::-;55484:6;55491:1;55484:9;;;;;;;;:::i;:::-;;;;;;;;;;:25;55553:3;;55442:141;;36040:117;36103:7;36130:19;36138:3;31524:18;;31441:109;44591:126;44663:7;44690:19;44698:3;44690:7;:19::i;44331:172::-;44418:4;44442:53;44452:3;-1:-1:-1;;;;;44472:21:0;;44442:9;:53::i;43678:240::-;43804:4;43828:82;43833:3;-1:-1:-1;;;;;43853:21:0;;;;43885:23;;41035:195;41145:4;41162:16;;;:11;;;:16;;;;;:24;;;41204:18;41162:3;41174;41204:13;:18::i;29130:414::-;29193:4;31323:19;;;:12;;;:19;;;;;;29210:327;;-1:-1:-1;29253:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;29436:18;;29414:19;;;:12;;;:19;;;;;;:40;;;;29469:11;;29210:327;-1:-1:-1;29520:5:0;29513:12;;31904:120;31971:7;31998:3;:11;;32010:5;31998:18;;;;;;;;:::i;:::-;;;;;;;;;31991:25;;31904:120;;;;:::o;45065:289::-;45175:7;;;;45240:22;45244:3;45256:5;45240:3;:22::i;82063:222::-;82171:40;82192:3;82197:13;:4;:11;:13::i;82171:40::-;82213:22;;;;;;;;;;;;;-1:-1:-1;;;82213:22:0;;;82163:73;;;;;-1:-1:-1;;;82163:73:0;;;;;;;;:::i;:::-;-1:-1:-1;82252:25:0;;82273:3;;82252:25;;;;;82063:222;;:::o;29720:1420::-;29786:4;29925:19;;;:12;;;:19;;;;;;29961:15;;29957:1176;;30336:21;30360:14;30373:1;30360:10;:14;:::i;:::-;30409:18;;30336:38;;-1:-1:-1;30389:17:0;;30409:22;;30430:1;;30409:22;:::i;:::-;30389:42;;30465:13;30452:9;:26;30448:405;;30499:17;30519:3;:11;;30531:9;30519:22;;;;;;;;:::i;:::-;;;;;;;;;30499:42;;30673:9;30644:3;:11;;30656:13;30644:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:38;;;;30758:23;;;:12;;;:23;;;;;:36;;;30448:405;30934:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;31029:3;:12;;:19;31042:5;31029:19;;;;;;;;;;;31022:26;;;31072:4;31065:11;;;;;;;29957:1176;31116:5;31109:12;;;;;41640:126;41711:4;41735:23;:3;41754;41735:18;:23::i;42661:290::-;42730:4;42772:16;;;:11;;;:16;;;;;;42730:4;;42803:19;42799:145;;42847:19;42857:3;42862;42847:9;:19::i;:::-;42839:40;-1:-1:-1;42876:1:0;;-1:-1:-1;42839:40:0;;-1:-1:-1;42839:40:0;42799:145;42920:4;;-1:-1:-1;42926:5:0;-1:-1:-1;42912:20:0;;43112:236;43178:7;43214:16;;;:11;;;:16;;;;;;43249:10;;;;:33;;;43263:19;43273:3;43278;43263:9;:19::i;:::-;43241:76;;;;-1:-1:-1;;;43241:76:0;;8580:2:1;43241:76:0;;;8562:21:1;8619:2;8599:18;;;8592:30;8658:32;8638:18;;;8631:60;8708:18;;43241:76:0;8378:354:1;53472:213:0;53600:7;;53643:13;:3;53650:5;53643:6;:13::i;:::-;-1:-1:-1;53625:31:0;53472:213;-1:-1:-1;;;;53472:213:0:o;41861:109::-;41917:7;41944:18;:3;:16;:18::i;42335:178::-;42402:7;;;42445:19;:3;42458:5;42445:12;:19::i;:::-;42488:16;;;;:11;;;;;:16;;;;;;;;;42335:178;-1:-1:-1;;;;42335:178:0:o;33457:140::-;33537:4;31323:19;;;:12;;;:19;;;;;;:24;;33561:28;31226:129;243:658:1;414:2;466:21;;;536:13;;439:18;;;558:22;;;385:4;;414:2;637:15;;;;611:2;596:18;;;385:4;680:195;694:6;691:1;688:13;680:195;;;759:13;;-1:-1:-1;;;;;755:39:1;743:52;;850:15;;;;815:12;;;;791:1;709:9;680:195;;;-1:-1:-1;892:3:1;;243:658;-1:-1:-1;;;;;;243:658:1:o;906:180::-;965:6;1018:2;1006:9;997:7;993:23;989:32;986:52;;;1034:1;1031;1024:12;986:52;-1:-1:-1;1057:23:1;;906:180;-1:-1:-1;906:180:1:o;1299:131::-;-1:-1:-1;;;;;1374:31:1;;1364:42;;1354:70;;1420:1;1417;1410:12;1354:70;1299:131;:::o;1435:315::-;1503:6;1511;1564:2;1552:9;1543:7;1539:23;1535:32;1532:52;;;1580:1;1577;1570:12;1532:52;1616:9;1603:23;1593:33;;1676:2;1665:9;1661:18;1648:32;1689:31;1714:5;1689:31;:::i;:::-;1739:5;1729:15;;;1435:315;;;;;:::o;1755:388::-;1823:6;1831;1884:2;1872:9;1863:7;1859:23;1855:32;1852:52;;;1900:1;1897;1890:12;1852:52;1939:9;1926:23;1958:31;1983:5;1958:31;:::i;:::-;2008:5;-1:-1:-1;2065:2:1;2050:18;;2037:32;2078:33;2037:32;2078:33;:::i;2333:247::-;2392:6;2445:2;2433:9;2424:7;2420:23;2416:32;2413:52;;;2461:1;2458;2451:12;2413:52;2500:9;2487:23;2519:31;2544:5;2519:31;:::i;3296:118::-;3382:5;3375:13;3368:21;3361:5;3358:32;3348:60;;3404:1;3401;3394:12;3419:450;3493:6;3501;3509;3562:2;3550:9;3541:7;3537:23;3533:32;3530:52;;;3578:1;3575;3568:12;3530:52;3614:9;3601:23;3591:33;;3674:2;3663:9;3659:18;3646:32;3687:31;3712:5;3687:31;:::i;:::-;3737:5;-1:-1:-1;3794:2:1;3779:18;;3766:32;3807:30;3766:32;3807:30;:::i;:::-;3856:7;3846:17;;;3419:450;;;;;:::o;4200:632::-;4371:2;4423:21;;;4493:13;;4396:18;;;4515:22;;;4342:4;;4371:2;4594:15;;;;4568:2;4553:18;;;4342:4;4637:169;4651:6;4648:1;4645:13;4637:169;;;4712:13;;4700:26;;4781:15;;;;4746:12;;;;4673:1;4666:9;4637:169;;5019:309;5084:6;5092;5145:2;5133:9;5124:7;5120:23;5116:32;5113:52;;;5161:1;5158;5151:12;5113:52;5197:9;5184:23;5174:33;;5257:2;5246:9;5242:18;5229:32;5270:28;5292:5;5270:28;:::i;5612:245::-;5679:6;5732:2;5720:9;5711:7;5707:23;5703:32;5700:52;;;5748:1;5745;5738:12;5700:52;5780:9;5774:16;5799:28;5821:5;5799:28;:::i;5862:597::-;5974:4;6003:2;6032;6021:9;6014:21;6064:6;6058:13;6107:6;6102:2;6091:9;6087:18;6080:34;6132:1;6142:140;6156:6;6153:1;6150:13;6142:140;;;6251:14;;;6247:23;;6241:30;6217:17;;;6236:2;6213:26;6206:66;6171:10;;6142:140;;;6300:6;6297:1;6294:13;6291:91;;;6370:1;6365:2;6356:6;6345:9;6341:22;6337:31;6330:42;6291:91;-1:-1:-1;6443:2:1;6422:15;-1:-1:-1;;6418:29:1;6403:45;;;;6450:2;6399:54;;5862:597;-1:-1:-1;;;5862:597:1:o;6464:251::-;6534:6;6587:2;6575:9;6566:7;6562:23;6558:32;6555:52;;;6603:1;6600;6593:12;6555:52;6635:9;6629:16;6654:31;6679:5;6654:31;:::i;7755:127::-;7816:10;7811:3;7807:20;7804:1;7797:31;7847:4;7844:1;7837:15;7871:4;7868:1;7861:15;7887:127;7948:10;7943:3;7939:20;7936:1;7929:31;7979:4;7976:1;7969:15;8003:4;8000:1;7993:15;8019:222;8059:4;8087:1;8084;8081:8;8078:131;;;8131:10;8126:3;8122:20;8119:1;8112:31;8166:4;8163:1;8156:15;8194:4;8191:1;8184:15;8078:131;-1:-1:-1;8226:9:1;;8019:222::o;8246:127::-;8307:10;8302:3;8298:20;8295:1;8288:31;8338:4;8335:1;8328:15;8362:4;8359:1;8352:15

ipfs://184c021181db840677a69772e4743af8c965b04dfb5bc8ad30d84519d8a6b033