{"file_path":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol","creation_status":"success","source_code":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.9;\n\nimport \"../../feeds/CustomAggregatorV3CompatibleFeed.sol\";\nimport \"./MGloMidasAccessControlRoles.sol\";\n\n/**\n * @title MGloCustomAggregatorFeed\n * @notice AggregatorV3 compatible feed for mGLO,\n * where price is submitted manually by feed admins\n * @author RedDuck Software\n */\ncontract MGloCustomAggregatorFeed is\n CustomAggregatorV3CompatibleFeed,\n MGloMidasAccessControlRoles\n{\n /**\n * @dev leaving a storage gap for futures updates\n */\n uint256[50] private __gap;\n\n /**\n * @inheritdoc CustomAggregatorV3CompatibleFeed\n */\n function feedAdminRole() public pure override returns (bytes32) {\n return M_GLO_CUSTOM_AGGREGATOR_FEED_ADMIN_ROLE;\n }\n}\n","deployed_bytecode":"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","optimization_enabled":true,"verified_twin_address_hash":null,"is_verified":true,"compiler_settings":{"evmVersion":"london","libraries":{},"metadata":{"bytecodeHash":"ipfs","useLiteralContent":true},"optimizer":{"enabled":true,"runs":200},"remappings":[]},"optimization_runs":200,"sourcify_repo_url":"https://repo.sourcify.dev/contracts/full_match/8453/0x4A0a3eAb5c75173C760B5a50a8570e5D20D9cC94/","decoded_constructor_args":null,"compiler_version":"0.8.9+commit.e5eed63a","is_verified_via_verifier_alliance":false,"verified_at":"2026-06-27T02:00:31.224072Z","implementations":[],"proxy_type":null,"external_libraries":[],"creation_bytecode":"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","name":"MGloCustomAggregatorFeed","is_blueprint":false,"license_type":"none","is_fully_verified":true,"is_verified_via_eth_bytecode_db":true,"language":"solidity","evm_version":"london","can_be_visualized_via_sol2uml":true,"is_verified_via_sourcify":true,"additional_sources":[{"file_path":"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../../utils/AddressUpgradeable.sol\";\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\n * reused. This mechanism prevents re-execution of each \"step\" but allows the creation of new initialization steps in\n * case an upgrade adds a module that needs to be initialized.\n *\n * For example:\n *\n * [.hljs-theme-light.nopadding]\n * ```solidity\n * contract MyToken is ERC20Upgradeable {\n * function initialize() initializer public {\n * __ERC20_init(\"MyToken\", \"MTK\");\n * }\n * }\n *\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\n * function initializeV2() reinitializer(2) public {\n * __ERC20Permit_init(\"MyToken\");\n * }\n * }\n * ```\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n *\n * [CAUTION]\n * ====\n * Avoid leaving a contract uninitialized.\n *\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * /// @custom:oz-upgrades-unsafe-allow constructor\n * constructor() {\n * _disableInitializers();\n * }\n * ```\n * ====\n */\nabstract contract Initializable {\n /**\n * @dev Indicates that the contract has been initialized.\n * @custom:oz-retyped-from bool\n */\n uint8 private _initialized;\n\n /**\n * @dev Indicates that the contract is in the process of being initialized.\n */\n bool private _initializing;\n\n /**\n * @dev Triggered when the contract has been initialized or reinitialized.\n */\n event Initialized(uint8 version);\n\n /**\n * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\n * `onlyInitializing` functions can be used to initialize parent contracts.\n *\n * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a\n * constructor.\n *\n * Emits an {Initialized} event.\n */\n modifier initializer() {\n bool isTopLevelCall = !_initializing;\n require(\n (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\n \"Initializable: contract is already initialized\"\n );\n _initialized = 1;\n if (isTopLevelCall) {\n _initializing = true;\n }\n _;\n if (isTopLevelCall) {\n _initializing = false;\n emit Initialized(1);\n }\n }\n\n /**\n * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\n * used to initialize parent contracts.\n *\n * A reinitializer may be used after the original initialization step. This is essential to configure modules that\n * are added through upgrades and that require initialization.\n *\n * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\n * cannot be nested. If one is invoked in the context of another, execution will revert.\n *\n * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\n * a contract, executing them in the right order is up to the developer or operator.\n *\n * WARNING: setting the version to 255 will prevent any future reinitialization.\n *\n * Emits an {Initialized} event.\n */\n modifier reinitializer(uint8 version) {\n require(!_initializing && _initialized < version, \"Initializable: contract is already initialized\");\n _initialized = version;\n _initializing = true;\n _;\n _initializing = false;\n emit Initialized(version);\n }\n\n /**\n * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\n */\n modifier onlyInitializing() {\n require(_initializing, \"Initializable: contract is not initializing\");\n _;\n }\n\n /**\n * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\n * through proxies.\n *\n * Emits an {Initialized} event the first time it is successfully executed.\n */\n function _disableInitializers() internal virtual {\n require(!_initializing, \"Initializable: contract is initializing\");\n if (_initialized != type(uint8).max) {\n _initialized = type(uint8).max;\n emit Initialized(type(uint8).max);\n }\n }\n\n /**\n * @dev Returns the highest version that has been initialized. See {reinitializer}.\n */\n function _getInitializedVersion() internal view returns (uint8) {\n return _initialized;\n }\n\n /**\n * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\n */\n function _isInitializing() internal view returns (bool) {\n return _initializing;\n }\n}\n"},{"file_path":"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface AggregatorV3Interface {\n function decimals() external view returns (uint8);\n\n function description() external view returns (string memory);\n\n function version() external view returns (uint256);\n\n function getRoundData(uint80 _roundId)\n external\n view\n returns (\n uint80 roundId,\n int256 answer,\n uint256 startedAt,\n uint256 updatedAt,\n uint80 answeredInRound\n );\n\n function latestRoundData()\n external\n view\n returns (\n uint80 roundId,\n int256 answer,\n uint256 startedAt,\n uint256 updatedAt,\n uint80 answeredInRound\n );\n}\n"},{"file_path":"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (access/AccessControl.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IAccessControlUpgradeable.sol\";\nimport \"../utils/ContextUpgradeable.sol\";\nimport \"../utils/StringsUpgradeable.sol\";\nimport \"../utils/introspection/ERC165Upgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module that allows children to implement role-based access\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\n * members except through off-chain means by accessing the contract event logs. Some\n * applications may benefit from on-chain enumerability, for those cases see\n * {AccessControlEnumerable}.\n *\n * Roles are referred to by their `bytes32` identifier. These should be exposed\n * in the external API and be unique. The best way to achieve this is by\n * using `public constant` hash digests:\n *\n * ```solidity\n * bytes32 public constant MY_ROLE = keccak256(\"MY_ROLE\");\n * ```\n *\n * Roles can be used to represent a set of permissions. To restrict access to a\n * function call, use {hasRole}:\n *\n * ```solidity\n * function foo() public {\n * require(hasRole(MY_ROLE, msg.sender));\n * ...\n * }\n * ```\n *\n * Roles can be granted and revoked dynamically via the {grantRole} and\n * {revokeRole} functions. Each role has an associated admin role, and only\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\n *\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\n * that only accounts with this role will be able to grant or revoke other\n * roles. More complex role relationships can be created by using\n * {_setRoleAdmin}.\n *\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\n * grant and revoke this role. Extra precautions should be taken to secure\n * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}\n * to enforce additional security measures for this role.\n */\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\n function __AccessControl_init() internal onlyInitializing {\n }\n\n function __AccessControl_init_unchained() internal onlyInitializing {\n }\n struct RoleData {\n mapping(address => bool) members;\n bytes32 adminRole;\n }\n\n mapping(bytes32 => RoleData) private _roles;\n\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\n\n /**\n * @dev Modifier that checks that an account has a specific role. Reverts\n * with a standardized message including the required role.\n *\n * The format of the revert reason is given by the following regular expression:\n *\n * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\n *\n * _Available since v4.1._\n */\n modifier onlyRole(bytes32 role) {\n _checkRole(role);\n _;\n }\n\n /**\n * @dev See {IERC165-supportsInterface}.\n */\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n return interfaceId == type(IAccessControlUpgradeable).interfaceId || super.supportsInterface(interfaceId);\n }\n\n /**\n * @dev Returns `true` if `account` has been granted `role`.\n */\n function hasRole(bytes32 role, address account) public view virtual override returns (bool) {\n return _roles[role].members[account];\n }\n\n /**\n * @dev Revert with a standard message if `_msgSender()` is missing `role`.\n * Overriding this function changes the behavior of the {onlyRole} modifier.\n *\n * Format of the revert message is described in {_checkRole}.\n *\n * _Available since v4.6._\n */\n function _checkRole(bytes32 role) internal view virtual {\n _checkRole(role, _msgSender());\n }\n\n /**\n * @dev Revert with a standard message if `account` is missing `role`.\n *\n * The format of the revert reason is given by the following regular expression:\n *\n * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\n */\n function _checkRole(bytes32 role, address account) internal view virtual {\n if (!hasRole(role, account)) {\n revert(\n string(\n abi.encodePacked(\n \"AccessControl: account \",\n StringsUpgradeable.toHexString(account),\n \" is missing role \",\n StringsUpgradeable.toHexString(uint256(role), 32)\n )\n )\n );\n }\n }\n\n /**\n * @dev Returns the admin role that controls `role`. See {grantRole} and\n * {revokeRole}.\n *\n * To change a role's admin, use {_setRoleAdmin}.\n */\n function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {\n return _roles[role].adminRole;\n }\n\n /**\n * @dev Grants `role` to `account`.\n *\n * If `account` had not been already granted `role`, emits a {RoleGranted}\n * event.\n *\n * Requirements:\n *\n * - the caller must have ``role``'s admin role.\n *\n * May emit a {RoleGranted} event.\n */\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\n _grantRole(role, account);\n }\n\n /**\n * @dev Revokes `role` from `account`.\n *\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\n *\n * Requirements:\n *\n * - the caller must have ``role``'s admin role.\n *\n * May emit a {RoleRevoked} event.\n */\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\n _revokeRole(role, account);\n }\n\n /**\n * @dev Revokes `role` from the calling account.\n *\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\n * purpose is to provide a mechanism for accounts to lose their privileges\n * if they are compromised (such as when a trusted device is misplaced).\n *\n * If the calling account had been revoked `role`, emits a {RoleRevoked}\n * event.\n *\n * Requirements:\n *\n * - the caller must be `account`.\n *\n * May emit a {RoleRevoked} event.\n */\n function renounceRole(bytes32 role, address account) public virtual override {\n require(account == _msgSender(), \"AccessControl: can only renounce roles for self\");\n\n _revokeRole(role, account);\n }\n\n /**\n * @dev Grants `role` to `account`.\n *\n * If `account` had not been already granted `role`, emits a {RoleGranted}\n * event. Note that unlike {grantRole}, this function doesn't perform any\n * checks on the calling account.\n *\n * May emit a {RoleGranted} event.\n *\n * [WARNING]\n * ====\n * This function should only be called from the constructor when setting\n * up the initial roles for the system.\n *\n * Using this function in any other way is effectively circumventing the admin\n * system imposed by {AccessControl}.\n * ====\n *\n * NOTE: This function is deprecated in favor of {_grantRole}.\n */\n function _setupRole(bytes32 role, address account) internal virtual {\n _grantRole(role, account);\n }\n\n /**\n * @dev Sets `adminRole` as ``role``'s admin role.\n *\n * Emits a {RoleAdminChanged} event.\n */\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\n bytes32 previousAdminRole = getRoleAdmin(role);\n _roles[role].adminRole = adminRole;\n emit RoleAdminChanged(role, previousAdminRole, adminRole);\n }\n\n /**\n * @dev Grants `role` to `account`.\n *\n * Internal function without access restriction.\n *\n * May emit a {RoleGranted} event.\n */\n function _grantRole(bytes32 role, address account) internal virtual {\n if (!hasRole(role, account)) {\n _roles[role].members[account] = true;\n emit RoleGranted(role, account, _msgSender());\n }\n }\n\n /**\n * @dev Revokes `role` from `account`.\n *\n * Internal function without access restriction.\n *\n * May emit a {RoleRevoked} event.\n */\n function _revokeRole(bytes32 role, address account) internal virtual {\n if (hasRole(role, account)) {\n _roles[role].members[account] = false;\n emit RoleRevoked(role, account, _msgSender());\n }\n }\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[49] private __gap;\n}\n"},{"file_path":"@openzeppelin/contracts-upgradeable/access/IAccessControlUpgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev External interface of AccessControl declared to support ERC165 detection.\n */\ninterface IAccessControlUpgradeable {\n /**\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\n *\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\n * {RoleAdminChanged} not being emitted signaling this.\n *\n * _Available since v3.1._\n */\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\n\n /**\n * @dev Emitted when `account` is granted `role`.\n *\n * `sender` is the account that originated the contract call, an admin role\n * bearer except when using {AccessControl-_setupRole}.\n */\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\n\n /**\n * @dev Emitted when `account` is revoked `role`.\n *\n * `sender` is the account that originated the contract call:\n * - if using `revokeRole`, it is the admin role bearer\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\n */\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\n\n /**\n * @dev Returns `true` if `account` has been granted `role`.\n */\n function hasRole(bytes32 role, address account) external view returns (bool);\n\n /**\n * @dev Returns the admin role that controls `role`. See {grantRole} and\n * {revokeRole}.\n *\n * To change a role's admin, use {AccessControl-_setRoleAdmin}.\n */\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\n\n /**\n * @dev Grants `role` to `account`.\n *\n * If `account` had not been already granted `role`, emits a {RoleGranted}\n * event.\n *\n * Requirements:\n *\n * - the caller must have ``role``'s admin role.\n */\n function grantRole(bytes32 role, address account) external;\n\n /**\n * @dev Revokes `role` from `account`.\n *\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\n *\n * Requirements:\n *\n * - the caller must have ``role``'s admin role.\n */\n function revokeRole(bytes32 role, address account) external;\n\n /**\n * @dev Revokes `role` from the calling account.\n *\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\n * purpose is to provide a mechanism for accounts to lose their privileges\n * if they are compromised (such as when a trusted device is misplaced).\n *\n * If the calling account had been granted `role`, emits a {RoleRevoked}\n * event.\n *\n * Requirements:\n *\n * - the caller must be `account`.\n */\n function renounceRole(bytes32 role, address account) external;\n}\n"},{"file_path":"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/ContextUpgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module which allows children to implement an emergency stop\n * mechanism that can be triggered by an authorized account.\n *\n * This module is used through inheritance. It will make available the\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\n * the functions of your contract. Note that they will not be pausable by\n * simply including this module, only once the modifiers are put in place.\n */\nabstract contract PausableUpgradeable is Initializable, ContextUpgradeable {\n /**\n * @dev Emitted when the pause is triggered by `account`.\n */\n event Paused(address account);\n\n /**\n * @dev Emitted when the pause is lifted by `account`.\n */\n event Unpaused(address account);\n\n bool private _paused;\n\n /**\n * @dev Initializes the contract in unpaused state.\n */\n function __Pausable_init() internal onlyInitializing {\n __Pausable_init_unchained();\n }\n\n function __Pausable_init_unchained() internal onlyInitializing {\n _paused = false;\n }\n\n /**\n * @dev Modifier to make a function callable only when the contract is not paused.\n *\n * Requirements:\n *\n * - The contract must not be paused.\n */\n modifier whenNotPaused() {\n _requireNotPaused();\n _;\n }\n\n /**\n * @dev Modifier to make a function callable only when the contract is paused.\n *\n * Requirements:\n *\n * - The contract must be paused.\n */\n modifier whenPaused() {\n _requirePaused();\n _;\n }\n\n /**\n * @dev Returns true if the contract is paused, and false otherwise.\n */\n function paused() public view virtual returns (bool) {\n return _paused;\n }\n\n /**\n * @dev Throws if the contract is paused.\n */\n function _requireNotPaused() internal view virtual {\n require(!paused(), \"Pausable: paused\");\n }\n\n /**\n * @dev Throws if the contract is not paused.\n */\n function _requirePaused() internal view virtual {\n require(paused(), \"Pausable: not paused\");\n }\n\n /**\n * @dev Triggers stopped state.\n *\n * Requirements:\n *\n * - The contract must not be paused.\n */\n function _pause() internal virtual whenNotPaused {\n _paused = true;\n emit Paused(_msgSender());\n }\n\n /**\n * @dev Returns to normal state.\n *\n * Requirements:\n *\n * - The contract must be paused.\n */\n function _unpause() internal virtual whenPaused {\n _paused = false;\n emit Unpaused(_msgSender());\n }\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[49] private __gap;\n}\n"},{"file_path":"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC20Upgradeable.sol\";\nimport \"./extensions/IERC20MetadataUpgradeable.sol\";\nimport \"../../utils/ContextUpgradeable.sol\";\nimport \"../../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20PresetMinterPauser}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * The default value of {decimals} is 18. To change this, you should override\n * this function so it returns a different value.\n *\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\n * instead returning `false` on failure. This behavior is nonetheless\n * conventional and does not conflict with the expectations of ERC20\n * applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\n mapping(address => uint256) private _balances;\n\n mapping(address => mapping(address => uint256)) private _allowances;\n\n uint256 private _totalSupply;\n\n string private _name;\n string private _symbol;\n\n /**\n * @dev Sets the values for {name} and {symbol}.\n *\n * All two of these values are immutable: they can only be set once during\n * construction.\n */\n function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {\n __ERC20_init_unchained(name_, symbol_);\n }\n\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {\n _name = name_;\n _symbol = symbol_;\n }\n\n /**\n * @dev Returns the name of the token.\n */\n function name() public view virtual override returns (string memory) {\n return _name;\n }\n\n /**\n * @dev Returns the symbol of the token, usually a shorter version of the\n * name.\n */\n function symbol() public view virtual override returns (string memory) {\n return _symbol;\n }\n\n /**\n * @dev Returns the number of decimals used to get its user representation.\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\n * be displayed to a user as `5.05` (`505 / 10 ** 2`).\n *\n * Tokens usually opt for a value of 18, imitating the relationship between\n * Ether and Wei. This is the default value returned by this function, unless\n * it's overridden.\n *\n * NOTE: This information is only used for _display_ purposes: it in\n * no way affects any of the arithmetic of the contract, including\n * {IERC20-balanceOf} and {IERC20-transfer}.\n */\n function decimals() public view virtual override returns (uint8) {\n return 18;\n }\n\n /**\n * @dev See {IERC20-totalSupply}.\n */\n function totalSupply() public view virtual override returns (uint256) {\n return _totalSupply;\n }\n\n /**\n * @dev See {IERC20-balanceOf}.\n */\n function balanceOf(address account) public view virtual override returns (uint256) {\n return _balances[account];\n }\n\n /**\n * @dev See {IERC20-transfer}.\n *\n * Requirements:\n *\n * - `to` cannot be the zero address.\n * - the caller must have a balance of at least `amount`.\n */\n function transfer(address to, uint256 amount) public virtual override returns (bool) {\n address owner = _msgSender();\n _transfer(owner, to, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-allowance}.\n */\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\n return _allowances[owner][spender];\n }\n\n /**\n * @dev See {IERC20-approve}.\n *\n * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\n * `transferFrom`. This is semantically equivalent to an infinite approval.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\n address owner = _msgSender();\n _approve(owner, spender, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-transferFrom}.\n *\n * Emits an {Approval} event indicating the updated allowance. This is not\n * required by the EIP. See the note at the beginning of {ERC20}.\n *\n * NOTE: Does not update the allowance if the current allowance\n * is the maximum `uint256`.\n *\n * Requirements:\n *\n * - `from` and `to` cannot be the zero address.\n * - `from` must have a balance of at least `amount`.\n * - the caller must have allowance for ``from``'s tokens of at least\n * `amount`.\n */\n function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {\n address spender = _msgSender();\n _spendAllowance(from, spender, amount);\n _transfer(from, to, amount);\n return true;\n }\n\n /**\n * @dev Atomically increases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n address owner = _msgSender();\n _approve(owner, spender, allowance(owner, spender) + addedValue);\n return true;\n }\n\n /**\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n * - `spender` must have allowance for the caller of at least\n * `subtractedValue`.\n */\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n address owner = _msgSender();\n uint256 currentAllowance = allowance(owner, spender);\n require(currentAllowance >= subtractedValue, \"ERC20: decreased allowance below zero\");\n unchecked {\n _approve(owner, spender, currentAllowance - subtractedValue);\n }\n\n return true;\n }\n\n /**\n * @dev Moves `amount` of tokens from `from` to `to`.\n *\n * This internal function is equivalent to {transfer}, and can be used to\n * e.g. implement automatic token fees, slashing mechanisms, etc.\n *\n * Emits a {Transfer} event.\n *\n * Requirements:\n *\n * - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n * - `from` must have a balance of at least `amount`.\n */\n function _transfer(address from, address to, uint256 amount) internal virtual {\n require(from != address(0), \"ERC20: transfer from the zero address\");\n require(to != address(0), \"ERC20: transfer to the zero address\");\n\n _beforeTokenTransfer(from, to, amount);\n\n uint256 fromBalance = _balances[from];\n require(fromBalance >= amount, \"ERC20: transfer amount exceeds balance\");\n unchecked {\n _balances[from] = fromBalance - amount;\n // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\n // decrementing then incrementing.\n _balances[to] += amount;\n }\n\n emit Transfer(from, to, amount);\n\n _afterTokenTransfer(from, to, amount);\n }\n\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n * the total supply.\n *\n * Emits a {Transfer} event with `from` set to the zero address.\n *\n * Requirements:\n *\n * - `account` cannot be the zero address.\n */\n function _mint(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: mint to the zero address\");\n\n _beforeTokenTransfer(address(0), account, amount);\n\n _totalSupply += amount;\n unchecked {\n // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\n _balances[account] += amount;\n }\n emit Transfer(address(0), account, amount);\n\n _afterTokenTransfer(address(0), account, amount);\n }\n\n /**\n * @dev Destroys `amount` tokens from `account`, reducing the\n * total supply.\n *\n * Emits a {Transfer} event with `to` set to the zero address.\n *\n * Requirements:\n *\n * - `account` cannot be the zero address.\n * - `account` must have at least `amount` tokens.\n */\n function _burn(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: burn from the zero address\");\n\n _beforeTokenTransfer(account, address(0), amount);\n\n uint256 accountBalance = _balances[account];\n require(accountBalance >= amount, \"ERC20: burn amount exceeds balance\");\n unchecked {\n _balances[account] = accountBalance - amount;\n // Overflow not possible: amount <= accountBalance <= totalSupply.\n _totalSupply -= amount;\n }\n\n emit Transfer(account, address(0), amount);\n\n _afterTokenTransfer(account, address(0), amount);\n }\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\n *\n * This internal function is equivalent to `approve`, and can be used to\n * e.g. set automatic allowances for certain subsystems, etc.\n *\n * Emits an {Approval} event.\n *\n * Requirements:\n *\n * - `owner` cannot be the zero address.\n * - `spender` cannot be the zero address.\n */\n function _approve(address owner, address spender, uint256 amount) internal virtual {\n require(owner != address(0), \"ERC20: approve from the zero address\");\n require(spender != address(0), \"ERC20: approve to the zero address\");\n\n _allowances[owner][spender] = amount;\n emit Approval(owner, spender, amount);\n }\n\n /**\n * @dev Updates `owner` s allowance for `spender` based on spent `amount`.\n *\n * Does not update the allowance amount in case of infinite allowance.\n * Revert if not enough allowance is available.\n *\n * Might emit an {Approval} event.\n */\n function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {\n uint256 currentAllowance = allowance(owner, spender);\n if (currentAllowance != type(uint256).max) {\n require(currentAllowance >= amount, \"ERC20: insufficient allowance\");\n unchecked {\n _approve(owner, spender, currentAllowance - amount);\n }\n }\n }\n\n /**\n * @dev Hook that is called before any transfer of tokens. This includes\n * minting and burning.\n *\n * Calling conditions:\n *\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n * will be transferred to `to`.\n * - when `from` is zero, `amount` tokens will be minted for `to`.\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n * - `from` and `to` are never both zero.\n *\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n */\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n\n /**\n * @dev Hook that is called after any transfer of tokens. This includes\n * minting and burning.\n *\n * Calling conditions:\n *\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n * has been transferred to `to`.\n * - when `from` is zero, `amount` tokens have been minted for `to`.\n * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\n * - `from` and `to` are never both zero.\n *\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n */\n function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[45] private __gap;\n}\n"},{"file_path":"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20Upgradeable {\n /**\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n *\n * Note that `value` may be zero.\n */\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /**\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n */\n event Approval(address indexed owner, address indexed spender, uint256 value);\n\n /**\n * @dev Returns the amount of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves `amount` tokens from the caller's account to `to`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address to, uint256 amount) external returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender) external view returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Moves `amount` tokens from `from` to `to` using the\n * allowance mechanism. `amount` is then deducted from the caller's\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address from, address to, uint256 amount) external returns (bool);\n}\n"},{"file_path":"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20PausableUpgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/ERC20Pausable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../ERC20Upgradeable.sol\";\nimport \"../../../security/PausableUpgradeable.sol\";\nimport \"../../../proxy/utils/Initializable.sol\";\n\n/**\n * @dev ERC20 token with pausable token transfers, minting and burning.\n *\n * Useful for scenarios such as preventing trades until the end of an evaluation\n * period, or having an emergency switch for freezing all token transfers in the\n * event of a large bug.\n *\n * IMPORTANT: This contract does not include public pause and unpause functions. In\n * addition to inheriting this contract, you must define both functions, invoking the\n * {Pausable-_pause} and {Pausable-_unpause} internal functions, with appropriate\n * access control, e.g. using {AccessControl} or {Ownable}. Not doing so will\n * make the contract unpausable.\n */\nabstract contract ERC20PausableUpgradeable is Initializable, ERC20Upgradeable, PausableUpgradeable {\n function __ERC20Pausable_init() internal onlyInitializing {\n __Pausable_init_unchained();\n }\n\n function __ERC20Pausable_init_unchained() internal onlyInitializing {\n }\n /**\n * @dev See {ERC20-_beforeTokenTransfer}.\n *\n * Requirements:\n *\n * - the contract must not be paused.\n */\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {\n super._beforeTokenTransfer(from, to, amount);\n\n require(!paused(), \"ERC20Pausable: token transfer while paused\");\n }\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[50] private __gap;\n}\n"},{"file_path":"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20Upgradeable.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\n /**\n * @dev Returns the name of the token.\n */\n function name() external view returns (string memory);\n\n /**\n * @dev Returns the symbol of the token.\n */\n function symbol() external view returns (string memory);\n\n /**\n * @dev Returns the decimals places of the token.\n */\n function decimals() external view returns (uint8);\n}\n"},{"file_path":"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary AddressUpgradeable {\n /**\n * @dev Returns true if `account` is a contract.\n *\n * [IMPORTANT]\n * ====\n * It is unsafe to assume that an address for which this function returns\n * false is an externally-owned account (EOA) and not a contract.\n *\n * Among others, `isContract` will return false for the following\n * types of addresses:\n *\n * - an externally-owned account\n * - a contract in construction\n * - an address where a contract will be created\n * - an address where a contract lived, but was destroyed\n *\n * Furthermore, `isContract` will also return true if the target contract within\n * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\n * which only has an effect at the end of a transaction.\n * ====\n *\n * [IMPORTANT]\n * ====\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\n *\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n * constructor.\n * ====\n */\n function isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize/address.code.length, which returns 0\n // for contracts in construction, since the code is only stored at the end\n // of the constructor execution.\n\n return account.code.length > 0;\n }\n\n /**\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n *\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n *\n * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n *\n * IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n (bool success, ) = recipient.call{value: amount}(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain `call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason, it is bubbled up by this\n * function (like regular Solidity function calls).\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, \"Address: low-level call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value,\n string memory errorMessage\n ) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n (bool success, bytes memory returndata) = target.call{value: value}(data);\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, \"Address: low-level static call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal view returns (bytes memory) {\n (bool success, bytes memory returndata) = target.staticcall(data);\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n (bool success, bytes memory returndata) = target.delegatecall(data);\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n }\n\n /**\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\n * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\n *\n * _Available since v4.8._\n */\n function verifyCallResultFromTarget(\n address target,\n bool success,\n bytes memory returndata,\n string memory errorMessage\n ) internal view returns (bytes memory) {\n if (success) {\n if (returndata.length == 0) {\n // only check isContract if the call was successful and the return data is empty\n // otherwise we already know that it was a contract\n require(isContract(target), \"Address: call to non-contract\");\n }\n return returndata;\n } else {\n _revert(returndata, errorMessage);\n }\n }\n\n /**\n * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\n * revert reason or using the provided one.\n *\n * _Available since v4.3._\n */\n function verifyCallResult(\n bool success,\n bytes memory returndata,\n string memory errorMessage\n ) internal pure returns (bytes memory) {\n if (success) {\n return returndata;\n } else {\n _revert(returndata, errorMessage);\n }\n }\n\n function _revert(bytes memory returndata, string memory errorMessage) private pure {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n /// @solidity memory-safe-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n}\n"},{"file_path":"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract ContextUpgradeable is Initializable {\n function __Context_init() internal onlyInitializing {\n }\n\n function __Context_init_unchained() internal onlyInitializing {\n }\n function _msgSender() internal view virtual returns (address) {\n return msg.sender;\n }\n\n function _msgData() internal view virtual returns (bytes calldata) {\n return msg.data;\n }\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[50] private __gap;\n}\n"},{"file_path":"contracts/access/MidasAccessControlRoles.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.9;\n\n/**\n * @title MidasAccessControlRoles\n * @notice Base contract that stores all roles descriptors\n * @author RedDuck Software\n */\nabstract contract MidasAccessControlRoles {\n /**\n * @notice actor that can change green list statuses of addresses\n */\n bytes32 public constant GREENLIST_OPERATOR_ROLE =\n keccak256(\"GREENLIST_OPERATOR_ROLE\");\n\n /**\n * @notice actor that can change black list statuses of addresses\n */\n bytes32 public constant BLACKLIST_OPERATOR_ROLE =\n keccak256(\"BLACKLIST_OPERATOR_ROLE\");\n\n /**\n * @notice actor that is greenlisted\n */\n bytes32 public constant GREENLISTED_ROLE = keccak256(\"GREENLISTED_ROLE\");\n\n /**\n * @notice actor that is blacklisted\n */\n bytes32 public constant BLACKLISTED_ROLE = keccak256(\"BLACKLISTED_ROLE\");\n}\n"},{"file_path":"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./math/MathUpgradeable.sol\";\nimport \"./math/SignedMathUpgradeable.sol\";\n\n/**\n * @dev String operations.\n */\nlibrary StringsUpgradeable {\n bytes16 private constant _SYMBOLS = \"0123456789abcdef\";\n uint8 private constant _ADDRESS_LENGTH = 20;\n\n /**\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n */\n function toString(uint256 value) internal pure returns (string memory) {\n unchecked {\n uint256 length = MathUpgradeable.log10(value) + 1;\n string memory buffer = new string(length);\n uint256 ptr;\n /// @solidity memory-safe-assembly\n assembly {\n ptr := add(buffer, add(32, length))\n }\n while (true) {\n ptr--;\n /// @solidity memory-safe-assembly\n assembly {\n mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\n }\n value /= 10;\n if (value == 0) break;\n }\n return buffer;\n }\n }\n\n /**\n * @dev Converts a `int256` to its ASCII `string` decimal representation.\n */\n function toString(int256 value) internal pure returns (string memory) {\n return string(abi.encodePacked(value < 0 ? \"-\" : \"\", toString(SignedMathUpgradeable.abs(value))));\n }\n\n /**\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n */\n function toHexString(uint256 value) internal pure returns (string memory) {\n unchecked {\n return toHexString(value, MathUpgradeable.log256(value) + 1);\n }\n }\n\n /**\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n */\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n bytes memory buffer = new bytes(2 * length + 2);\n buffer[0] = \"0\";\n buffer[1] = \"x\";\n for (uint256 i = 2 * length + 1; i > 1; --i) {\n buffer[i] = _SYMBOLS[value & 0xf];\n value >>= 4;\n }\n require(value == 0, \"Strings: hex length insufficient\");\n return string(buffer);\n }\n\n /**\n * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.\n */\n function toHexString(address addr) internal pure returns (string memory) {\n return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);\n }\n\n /**\n * @dev Returns true if the two strings are equal.\n */\n function equal(string memory a, string memory b) internal pure returns (bool) {\n return keccak256(bytes(a)) == keccak256(bytes(b));\n }\n}\n"},{"file_path":"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC165Upgradeable.sol\";\nimport \"../../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n *\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\n */\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\n function __ERC165_init() internal onlyInitializing {\n }\n\n function __ERC165_init_unchained() internal onlyInitializing {\n }\n /**\n * @dev See {IERC165-supportsInterface}.\n */\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n return interfaceId == type(IERC165Upgradeable).interfaceId;\n }\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[50] private __gap;\n}\n"},{"file_path":"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165Upgradeable {\n /**\n * @dev Returns true if this contract implements the interface defined by\n * `interfaceId`. See the corresponding\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\n * to learn more about how these ids are created.\n *\n * This function call must use less than 30 000 gas.\n */\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"},{"file_path":"@openzeppelin/contracts-upgradeable/utils/math/MathUpgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary MathUpgradeable {\n enum Rounding {\n Down, // Toward negative infinity\n Up, // Toward infinity\n Zero // Toward zero\n }\n\n /**\n * @dev Returns the largest of two numbers.\n */\n function max(uint256 a, uint256 b) internal pure returns (uint256) {\n return a > b ? a : b;\n }\n\n /**\n * @dev Returns the smallest of two numbers.\n */\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\n return a < b ? a : b;\n }\n\n /**\n * @dev Returns the average of two numbers. The result is rounded towards\n * zero.\n */\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\n // (a + b) / 2 can overflow.\n return (a & b) + (a ^ b) / 2;\n }\n\n /**\n * @dev Returns the ceiling of the division of two numbers.\n *\n * This differs from standard division with `/` in that it rounds up instead\n * of rounding down.\n */\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n // (a + b - 1) / b can overflow on addition, so we distribute.\n return a == 0 ? 0 : (a - 1) / b + 1;\n }\n\n /**\n * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\n * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\n * with further edits by Uniswap Labs also under MIT license.\n */\n function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n unchecked {\n // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\n // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n // variables such that product = prod1 * 2^256 + prod0.\n uint256 prod0; // Least significant 256 bits of the product\n uint256 prod1; // Most significant 256 bits of the product\n assembly {\n let mm := mulmod(x, y, not(0))\n prod0 := mul(x, y)\n prod1 := sub(sub(mm, prod0), lt(mm, prod0))\n }\n\n // Handle non-overflow cases, 256 by 256 division.\n if (prod1 == 0) {\n // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n // The surrounding unchecked block does not change this fact.\n // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n return prod0 / denominator;\n }\n\n // Make sure the result is less than 2^256. Also prevents denominator == 0.\n require(denominator > prod1, \"Math: mulDiv overflow\");\n\n ///////////////////////////////////////////////\n // 512 by 256 division.\n ///////////////////////////////////////////////\n\n // Make division exact by subtracting the remainder from [prod1 prod0].\n uint256 remainder;\n assembly {\n // Compute remainder using mulmod.\n remainder := mulmod(x, y, denominator)\n\n // Subtract 256 bit number from 512 bit number.\n prod1 := sub(prod1, gt(remainder, prod0))\n prod0 := sub(prod0, remainder)\n }\n\n // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\n // See https://cs.stackexchange.com/q/138556/92363.\n\n // Does not overflow because the denominator cannot be zero at this stage in the function.\n uint256 twos = denominator & (~denominator + 1);\n assembly {\n // Divide denominator by twos.\n denominator := div(denominator, twos)\n\n // Divide [prod1 prod0] by twos.\n prod0 := div(prod0, twos)\n\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\n twos := add(div(sub(0, twos), twos), 1)\n }\n\n // Shift in bits from prod1 into prod0.\n prod0 |= prod1 * twos;\n\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\n // four bits. That is, denominator * inv = 1 mod 2^4.\n uint256 inverse = (3 * denominator) ^ 2;\n\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\n // in modular arithmetic, doubling the correct bits in each step.\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\n inverse *= 2 - denominator * inverse; // inverse mod 2^32\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\n\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\n // is no longer required.\n result = prod0 * inverse;\n return result;\n }\n }\n\n /**\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\n */\n function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\n uint256 result = mulDiv(x, y, denominator);\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\n result += 1;\n }\n return result;\n }\n\n /**\n * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\n *\n * Inspired by Henry S. Warren, Jr.'s \"Hacker's Delight\" (Chapter 11).\n */\n function sqrt(uint256 a) internal pure returns (uint256) {\n if (a == 0) {\n return 0;\n }\n\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\n //\n // We know that the \"msb\" (most significant bit) of our target number `a` is a power of 2 such that we have\n // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\n //\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\n // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\n // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\n //\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\n uint256 result = 1 << (log2(a) >> 1);\n\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\n // into the expected uint128 result.\n unchecked {\n result = (result + a / result) >> 1;\n result = (result + a / result) >> 1;\n result = (result + a / result) >> 1;\n result = (result + a / result) >> 1;\n result = (result + a / result) >> 1;\n result = (result + a / result) >> 1;\n result = (result + a / result) >> 1;\n return min(result, a / result);\n }\n }\n\n /**\n * @notice Calculates sqrt(a), following the selected rounding direction.\n */\n function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n unchecked {\n uint256 result = sqrt(a);\n return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\n }\n }\n\n /**\n * @dev Return the log in base 2, rounded down, of a positive value.\n * Returns 0 if given 0.\n */\n function log2(uint256 value) internal pure returns (uint256) {\n uint256 result = 0;\n unchecked {\n if (value >> 128 > 0) {\n value >>= 128;\n result += 128;\n }\n if (value >> 64 > 0) {\n value >>= 64;\n result += 64;\n }\n if (value >> 32 > 0) {\n value >>= 32;\n result += 32;\n }\n if (value >> 16 > 0) {\n value >>= 16;\n result += 16;\n }\n if (value >> 8 > 0) {\n value >>= 8;\n result += 8;\n }\n if (value >> 4 > 0) {\n value >>= 4;\n result += 4;\n }\n if (value >> 2 > 0) {\n value >>= 2;\n result += 2;\n }\n if (value >> 1 > 0) {\n result += 1;\n }\n }\n return result;\n }\n\n /**\n * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n * Returns 0 if given 0.\n */\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n unchecked {\n uint256 result = log2(value);\n return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\n }\n }\n\n /**\n * @dev Return the log in base 10, rounded down, of a positive value.\n * Returns 0 if given 0.\n */\n function log10(uint256 value) internal pure returns (uint256) {\n uint256 result = 0;\n unchecked {\n if (value >= 10 ** 64) {\n value /= 10 ** 64;\n result += 64;\n }\n if (value >= 10 ** 32) {\n value /= 10 ** 32;\n result += 32;\n }\n if (value >= 10 ** 16) {\n value /= 10 ** 16;\n result += 16;\n }\n if (value >= 10 ** 8) {\n value /= 10 ** 8;\n result += 8;\n }\n if (value >= 10 ** 4) {\n value /= 10 ** 4;\n result += 4;\n }\n if (value >= 10 ** 2) {\n value /= 10 ** 2;\n result += 2;\n }\n if (value >= 10 ** 1) {\n result += 1;\n }\n }\n return result;\n }\n\n /**\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n * Returns 0 if given 0.\n */\n function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n unchecked {\n uint256 result = log10(value);\n return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);\n }\n }\n\n /**\n * @dev Return the log in base 256, rounded down, of a positive value.\n * Returns 0 if given 0.\n *\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n */\n function log256(uint256 value) internal pure returns (uint256) {\n uint256 result = 0;\n unchecked {\n if (value >> 128 > 0) {\n value >>= 128;\n result += 16;\n }\n if (value >> 64 > 0) {\n value >>= 64;\n result += 8;\n }\n if (value >> 32 > 0) {\n value >>= 32;\n result += 4;\n }\n if (value >> 16 > 0) {\n value >>= 16;\n result += 2;\n }\n if (value >> 8 > 0) {\n result += 1;\n }\n }\n return result;\n }\n\n /**\n * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\n * Returns 0 if given 0.\n */\n function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n unchecked {\n uint256 result = log256(value);\n return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);\n }\n }\n}\n"},{"file_path":"@openzeppelin/contracts-upgradeable/utils/math/SignedMathUpgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard signed math utilities missing in the Solidity language.\n */\nlibrary SignedMathUpgradeable {\n /**\n * @dev Returns the largest of two signed numbers.\n */\n function max(int256 a, int256 b) internal pure returns (int256) {\n return a > b ? a : b;\n }\n\n /**\n * @dev Returns the smallest of two signed numbers.\n */\n function min(int256 a, int256 b) internal pure returns (int256) {\n return a < b ? a : b;\n }\n\n /**\n * @dev Returns the average of two signed numbers without overflow.\n * The result is rounded towards zero.\n */\n function average(int256 a, int256 b) internal pure returns (int256) {\n // Formula from the book \"Hacker's Delight\"\n int256 x = (a & b) + ((a ^ b) >> 1);\n return x + (int256(uint256(x) >> 255) & (a ^ b));\n }\n\n /**\n * @dev Returns the absolute unsigned value of a signed value.\n */\n function abs(int256 n) internal pure returns (uint256) {\n unchecked {\n // must be unchecked in order to support `n = type(int256).min`\n return uint256(n >= 0 ? n : -n);\n }\n }\n}\n"},{"file_path":"contracts/abstract/MidasInitializable.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.9;\n\nimport \"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\";\n\n/**\n * @title MidasInitializable\n * @author RedDuck Software\n * @notice Base Initializable contract that implements constructor\n * that calls _disableInitializers() to prevent\n * initialization of implementation contract\n */\nabstract contract MidasInitializable is Initializable {\n /// @custom:oz-upgrades-unsafe-allow constructor\n constructor() {\n _disableInitializers();\n }\n}\n"},{"file_path":"contracts/access/MidasAccessControl.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.9;\n\nimport \"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\";\n\nimport \"./MidasAccessControlRoles.sol\";\nimport \"../abstract/MidasInitializable.sol\";\n\n/**\n * @title MidasAccessControl\n * @notice Smart contract that stores all roles for Midas project\n * @author RedDuck Software\n */\ncontract MidasAccessControl is\n AccessControlUpgradeable,\n MidasInitializable,\n MidasAccessControlRoles\n{\n /**\n * @notice upgradeable pattern contract`s initializer\n */\n function initialize() external initializer {\n __AccessControl_init();\n _setupRoles(msg.sender);\n }\n\n /**\n * @notice grant multiple roles to multiple users\n * in one transaction\n * @dev length`s of 2 arays should match\n * @param roles array of bytes32 roles\n * @param addresses array of user addresses\n */\n function grantRoleMult(bytes32[] memory roles, address[] memory addresses)\n external\n {\n require(roles.length == addresses.length, \"MAC: mismatch arrays\");\n\n for (uint256 i = 0; i < roles.length; i++) {\n _checkRole(getRoleAdmin(roles[i]), msg.sender);\n _grantRole(roles[i], addresses[i]);\n }\n }\n\n /**\n * @notice revoke multiple roles from multiple users\n * in one transaction\n * @dev length`s of 2 arays should match\n * @param roles array of bytes32 roles\n * @param addresses array of user addresses\n */\n function revokeRoleMult(bytes32[] memory roles, address[] memory addresses)\n external\n {\n require(roles.length == addresses.length, \"MAC: mismatch arrays\");\n for (uint256 i = 0; i < roles.length; i++) {\n _checkRole(getRoleAdmin(roles[i]), msg.sender);\n _revokeRole(roles[i], addresses[i]);\n }\n }\n\n //solhint-disable disable-next-line\n function renounceRole(bytes32, address) public pure override {\n revert(\"MAC: Forbidden\");\n }\n\n /**\n * @dev setup roles during the contracts initialization\n */\n function _setupRoles(address admin) private {\n _grantRole(DEFAULT_ADMIN_ROLE, admin);\n\n _setRoleAdmin(BLACKLISTED_ROLE, BLACKLIST_OPERATOR_ROLE);\n _setRoleAdmin(GREENLISTED_ROLE, GREENLIST_OPERATOR_ROLE);\n }\n}\n"},{"file_path":"contracts/access/WithMidasAccessControl.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.9;\n\nimport \"./MidasAccessControl.sol\";\nimport \"../abstract/MidasInitializable.sol\";\n\n/**\n * @title WithMidasAccessControl\n * @notice Base contract that consumes MidasAccessControl\n * @author RedDuck Software\n */\nabstract contract WithMidasAccessControl is\n MidasInitializable,\n MidasAccessControlRoles\n{\n /**\n * @notice admin role\n */\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\n\n /**\n * @notice MidasAccessControl contract address\n */\n MidasAccessControl public accessControl;\n\n /**\n * @dev leaving a storage gap for futures updates\n */\n uint256[50] private __gap;\n\n /**\n * @dev checks that given `address` have `role`\n */\n modifier onlyRole(bytes32 role, address account) {\n _onlyRole(role, account);\n _;\n }\n\n /**\n * @dev checks that given `address` do not have `role`\n */\n modifier onlyNotRole(bytes32 role, address account) {\n _onlyNotRole(role, account);\n _;\n }\n\n /**\n * @dev upgradeable pattern contract`s initializer\n */\n // solhint-disable func-name-mixedcase\n function __WithMidasAccessControl_init(address _accessControl)\n internal\n onlyInitializing\n {\n require(_accessControl != address(0), \"zero address\");\n accessControl = MidasAccessControl(_accessControl);\n }\n\n /**\n * @dev checks that given `address` have `role`\n */\n function _onlyRole(bytes32 role, address account) internal view {\n require(accessControl.hasRole(role, account), \"WMAC: hasnt role\");\n }\n\n /**\n * @dev checks that given `address` do not have `role`\n */\n function _onlyNotRole(bytes32 role, address account) internal view {\n require(!accessControl.hasRole(role, account), \"WMAC: has role\");\n }\n}\n"},{"file_path":"contracts/feeds/CustomAggregatorV3CompatibleFeed.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.9;\n\nimport \"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20PausableUpgradeable.sol\";\nimport \"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\";\n\nimport \"../access/WithMidasAccessControl.sol\";\nimport \"../libraries/DecimalsCorrectionLibrary.sol\";\nimport \"../interfaces/IDataFeed.sol\";\n\n/**\n * @title CustomAggregatorV3CompatibleFeed\n * @notice AggregatorV3 compatible feed, where price is submitted manually by feed admins\n * @author RedDuck Software\n */\ncontract CustomAggregatorV3CompatibleFeed is\n WithMidasAccessControl,\n AggregatorV3Interface\n{\n struct RoundData {\n uint80 roundId;\n int256 answer;\n uint256 startedAt;\n uint256 updatedAt;\n uint80 answeredInRound;\n }\n\n /**\n * @notice feed description\n */\n string public override description;\n\n /**\n * @notice last round id\n */\n uint80 public latestRound;\n\n /**\n * @notice max deviation from lattest price in %\n * @dev 10 ** decimals() is a percentage precision\n */\n uint256 public maxAnswerDeviation;\n\n /**\n * @notice minimal possible answer that feed can return\n */\n int192 public minAnswer;\n\n /**\n * @notice maximal possible answer that feed can return\n */\n int192 public maxAnswer;\n\n /**\n * @dev holds round information\n */\n mapping(uint80 => RoundData) private _roundData;\n\n event AnswerUpdated(\n int256 indexed data,\n uint256 indexed roundId,\n uint256 indexed timestamp\n );\n\n /**\n * @dev checks that msg.sender do have a feedAdminRole() role\n */\n modifier onlyAggregatorAdmin() {\n _onlyRole(feedAdminRole(), msg.sender);\n _;\n }\n\n /**\n * @notice upgradeable pattern contract`s initializer\n * @param _accessControl address of MidasAccessControll contract\n * @param _minAnswer init value for `minAnswer`. Should be < `_maxAnswer`\n * @param _maxAnswer init value for `maxAnswer`. Should be > `_minAnswer`\n * @param _maxAnswerDeviation init value for `maxAnswerDeviation`\n * @param _description init value for `description`\n */\n function initialize(\n address _accessControl,\n int192 _minAnswer,\n int192 _maxAnswer,\n uint256 _maxAnswerDeviation,\n string calldata _description\n ) public virtual initializer {\n __WithMidasAccessControl_init(_accessControl);\n\n require(_minAnswer < _maxAnswer, \"CA: !min/max\");\n require(\n _maxAnswerDeviation <= 100 * (10**decimals()),\n \"CA: !max deviation\"\n );\n\n minAnswer = _minAnswer;\n maxAnswer = _maxAnswer;\n maxAnswerDeviation = _maxAnswerDeviation;\n description = _description;\n }\n\n /**\n * @notice works as `setRoundData()`, but also checks the\n * deviation with the lattest submitted data, and that at least\n * 1 hour passed since the lattest submission\n * @dev deviation with previous data needs to be <= `maxAnswerDeviation`\n * @param _data data value\n */\n function setRoundDataSafe(int256 _data) external {\n uint256 _lastUpdatedAt = lastTimestamp();\n\n if (_lastUpdatedAt != 0) {\n uint256 deviation = _getDeviation(lastAnswer(), _data);\n require(deviation <= maxAnswerDeviation, \"CA: !deviation\");\n }\n\n require(\n block.timestamp - _lastUpdatedAt > 1 hours,\n \"CA: not enough time passed\"\n );\n\n return setRoundData(_data);\n }\n\n /**\n * @notice sets the data for `latestRound` + 1 round id\n * @dev `_data` should be >= `minAnswer` and <= `maxAnswer`.\n * Function should be called only from address with `feedAdminRole()`\n * @param _data data value\n */\n function setRoundData(int256 _data) public onlyAggregatorAdmin {\n require(\n _data >= minAnswer && _data <= maxAnswer,\n \"CA: out of [min;max]\"\n );\n\n uint80 roundId = latestRound + 1;\n\n _roundData[roundId] = RoundData({\n roundId: roundId,\n answer: _data,\n startedAt: block.timestamp,\n updatedAt: block.timestamp,\n answeredInRound: roundId\n });\n\n latestRound = roundId;\n\n emit AnswerUpdated(_data, roundId, block.timestamp);\n }\n\n /**\n * @inheritdoc AggregatorV3Interface\n */\n function latestRoundData()\n external\n view\n returns (\n uint80 roundId,\n int256 answer,\n uint256 startedAt,\n uint256 updatedAt,\n uint80 answeredInRound\n )\n {\n return getRoundData(latestRound);\n }\n\n /**\n * @inheritdoc AggregatorV3Interface\n */\n function version() external pure returns (uint256) {\n return 1;\n }\n\n /**\n * @return answer of lattest price submission\n */\n function lastAnswer() public view returns (int256) {\n return _roundData[latestRound].answer;\n }\n\n /**\n * @return timestamp of lattest price submission\n */\n function lastTimestamp() public view returns (uint256) {\n return _roundData[latestRound].updatedAt;\n }\n\n /**\n * @inheritdoc AggregatorV3Interface\n */\n function getRoundData(uint80 _roundId)\n public\n view\n returns (\n uint80 roundId,\n int256 answer,\n uint256 startedAt,\n uint256 updatedAt,\n uint80 answeredInRound\n )\n {\n RoundData memory roundData = _roundData[_roundId];\n return (\n roundData.roundId,\n roundData.answer,\n roundData.startedAt,\n roundData.updatedAt,\n roundData.answeredInRound\n );\n }\n\n /**\n * @dev describes a role, owner of which can update prices in this feed\n * @return role descriptor\n */\n function feedAdminRole() public view virtual returns (bytes32) {\n return DEFAULT_ADMIN_ROLE;\n }\n\n /**\n * @inheritdoc AggregatorV3Interface\n */\n function decimals() public pure returns (uint8) {\n return 8;\n }\n\n /**\n * @dev calculates a deviation in % between `_lastPrice` and `_newPrice`\n * @return deviation in `10 ** decimals()` precision\n */\n function _getDeviation(int256 _lastPrice, int256 _newPrice)\n internal\n pure\n returns (uint256)\n {\n if (_newPrice == 0) return 100 * 10**decimals();\n int256 one = int256(10**decimals());\n int256 priceDif = _newPrice - _lastPrice;\n int256 deviation = (priceDif * one * 100) / _lastPrice;\n deviation = deviation < 0 ? deviation * -1 : deviation;\n return uint256(deviation);\n }\n}\n"},{"file_path":"contracts/interfaces/IDataFeed.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.9;\n\nimport \"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20PausableUpgradeable.sol\";\nimport \"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\";\n\nimport \"../access/WithMidasAccessControl.sol\";\nimport \"../libraries/DecimalsCorrectionLibrary.sol\";\n\n/**\n * @title IDataFeed\n * @author RedDuck Software\n */\ninterface IDataFeed {\n /**\n * @notice fetches answer from aggregator\n * and converts it to the base18 precision\n * @return answer fetched aggregator answer\n */\n function getDataInBase18() external view returns (uint256 answer);\n\n /**\n * @dev describes a role, owner of which can manage this feed\n * @return role descriptor\n */\n function feedAdminRole() external view returns (bytes32);\n}\n"},{"file_path":"contracts/libraries/DecimalsCorrectionLibrary.sol","source_code":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.9;\n\n/**\n * @title DecimalsCorrectionLibrary\n * @author RedDuck Software\n */\nlibrary DecimalsCorrectionLibrary {\n /**\n * @dev converts `originalAmount` with `originalDecimals` into\n * amount with `decidedDecimals`\n * @param originalAmount amount to convert\n * @param originalDecimals decimals of the original amount\n * @param decidedDecimals decimals for the output amount\n * @return amount converted amount with `decidedDecimals`\n */\n function convert(\n uint256 originalAmount,\n uint256 originalDecimals,\n uint256 decidedDecimals\n ) internal pure returns (uint256) {\n if (originalAmount == 0) return 0;\n if (originalDecimals == decidedDecimals) return originalAmount;\n\n uint256 adjustedAmount;\n\n if (originalDecimals > decidedDecimals) {\n adjustedAmount =\n originalAmount /\n (10**(originalDecimals - decidedDecimals));\n } else {\n adjustedAmount =\n originalAmount *\n (10**(decidedDecimals - originalDecimals));\n }\n\n return adjustedAmount;\n }\n\n /**\n * @dev converts `originalAmount` with decimals 18 into\n * amount with `decidedDecimals`\n * @param originalAmount amount to convert\n * @param decidedDecimals decimals for the output amount\n * @return amount converted amount with `decidedDecimals`\n */\n function convertFromBase18(uint256 originalAmount, uint256 decidedDecimals)\n internal\n pure\n returns (uint256)\n {\n return convert(originalAmount, 18, decidedDecimals);\n }\n\n /**\n * @dev converts `originalAmount` with `originalDecimals` into\n * amount with decimals 18\n * @param originalAmount amount to convert\n * @param originalDecimals decimals of the original amount\n * @return amount converted amount with 18 decimals\n */\n function convertToBase18(uint256 originalAmount, uint256 originalDecimals)\n internal\n pure\n returns (uint256)\n {\n return convert(originalAmount, originalDecimals, 18);\n }\n}\n"},{"file_path":"contracts/products/mGLO/MGloMidasAccessControlRoles.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.9;\n\n/**\n * @title MGloMidasAccessControlRoles\n * @notice Base contract that stores all roles descriptors for mGLO contracts\n * @author RedDuck Software\n */\nabstract contract MGloMidasAccessControlRoles {\n /**\n * @notice actor that can manage MGloDepositVault\n */\n bytes32 public constant M_GLO_DEPOSIT_VAULT_ADMIN_ROLE =\n keccak256(\"M_GLO_DEPOSIT_VAULT_ADMIN_ROLE\");\n\n /**\n * @notice actor that can manage MGloRedemptionVault\n */\n bytes32 public constant M_GLO_REDEMPTION_VAULT_ADMIN_ROLE =\n keccak256(\"M_GLO_REDEMPTION_VAULT_ADMIN_ROLE\");\n\n /**\n * @notice actor that can manage MGloCustomAggregatorFeed and MGloDataFeed\n */\n bytes32 public constant M_GLO_CUSTOM_AGGREGATOR_FEED_ADMIN_ROLE =\n keccak256(\"M_GLO_CUSTOM_AGGREGATOR_FEED_ADMIN_ROLE\");\n\n /**\n * @notice greenlist role for mGLO\n */\n bytes32 public constant M_GLOBAL_GREENLISTED_ROLE =\n keccak256(\"M_GLOBAL_GREENLISTED_ROLE\");\n}\n"}],"certified":false,"conflicting_implementations":null,"abi":[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"int256","name":"data","type":"int256"},{"indexed":true,"internalType":"uint256","name":"roundId","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"AnswerUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"inputs":[],"name":"BLACKLISTED_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BLACKLIST_OPERATOR_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"GREENLISTED_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"GREENLIST_OPERATOR_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"M_GLOBAL_GREENLISTED_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"M_GLO_CUSTOM_AGGREGATOR_FEED_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"M_GLO_DEPOSIT_VAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"M_GLO_REDEMPTION_VAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"accessControl","outputs":[{"internalType":"contract MidasAccessControl","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"description","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feedAdminRole","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint80","name":"_roundId","type":"uint80"}],"name":"getRoundData","outputs":[{"internalType":"uint80","name":"roundId","type":"uint80"},{"internalType":"int256","name":"answer","type":"int256"},{"internalType":"uint256","name":"startedAt","type":"uint256"},{"internalType":"uint256","name":"updatedAt","type":"uint256"},{"internalType":"uint80","name":"answeredInRound","type":"uint80"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_accessControl","type":"address"},{"internalType":"int192","name":"_minAnswer","type":"int192"},{"internalType":"int192","name":"_maxAnswer","type":"int192"},{"internalType":"uint256","name":"_maxAnswerDeviation","type":"uint256"},{"internalType":"string","name":"_description","type":"string"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"lastAnswer","outputs":[{"internalType":"int256","name":"","type":"int256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"latestRound","outputs":[{"internalType":"uint80","name":"","type":"uint80"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"latestRoundData","outputs":[{"internalType":"uint80","name":"roundId","type":"uint80"},{"internalType":"int256","name":"answer","type":"int256"},{"internalType":"uint256","name":"startedAt","type":"uint256"},{"internalType":"uint256","name":"updatedAt","type":"uint256"},{"internalType":"uint80","name":"answeredInRound","type":"uint80"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxAnswer","outputs":[{"internalType":"int192","name":"","type":"int192"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxAnswerDeviation","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minAnswer","outputs":[{"internalType":"int192","name":"","type":"int192"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"int256","name":"_data","type":"int256"}],"name":"setRoundData","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"int256","name":"_data","type":"int256"}],"name":"setRoundDataSafe","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"version","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}],"is_changed_bytecode":false,"is_partially_verified":false,"constructor_args":null}