Feature Tip: Add private address tag to any address under My Name Tag !
Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 1 internal transaction
Advanced mode:
Parent Transaction Hash | Block |
From
|
To
|
|||
---|---|---|---|---|---|---|
19594488 | 319 days ago | Contract Creation | 0 ETH |
Loading...
Loading
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.
Contract Source Code Verified (Exact Match)
Contract Name:
MasterRegistry
Compiler Version
v0.8.18+commit.87f61d96
Optimization Enabled:
Yes with 200 runs
Other Settings:
paris EvmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.18; import { AccessControlEnumerable } from "@openzeppelin/contracts/access/AccessControlEnumerable.sol"; import { Multicall } from "@openzeppelin/contracts/utils/Multicall.sol"; import { IMasterRegistry } from "./interfaces/IMasterRegistry.sol"; import { Errors } from "./libraries/Errors.sol"; /** * @title MasterRegistry * @notice This contract holds list of other registries or contracts and its historical versions. */ contract MasterRegistry is IMasterRegistry, AccessControlEnumerable, Multicall { /// @notice Role responsible for adding registries. bytes32 private constant MANAGER_ROLE = keccak256("MANAGER_ROLE"); //slither-disable-next-line uninitialized-state mapping(bytes32 => address[]) private _registryMap; //slither-disable-next-line uninitialized-state mapping(address => ReverseRegistryData) private _reverseRegistry; /** * @notice Add a new registry entry to the master list. * @param name address of the added pool * @param registryAddress address of the registry * @param version version of the registry */ event AddRegistry(bytes32 indexed name, address registryAddress, uint256 version); /** * @notice Update a current registry entry to the master list. * @param name address of the added pool * @param registryAddress address of the registry * @param version version of the registry */ event UpdateRegistry(bytes32 indexed name, address registryAddress, uint256 version); // slither-disable-next-line locked-ether constructor(address admin, address manager) payable { _grantRole(DEFAULT_ADMIN_ROLE, admin); _grantRole(MANAGER_ROLE, admin); _grantRole(MANAGER_ROLE, manager); } /// @inheritdoc IMasterRegistry function addRegistry(bytes32 registryName, address registryAddress) external override onlyRole(MANAGER_ROLE) { // Check for empty values. if (registryName == 0) revert Errors.NameEmpty(); if (registryAddress == address(0)) revert Errors.AddressEmpty(); // Check that the registry name is not already in use. address[] storage registry = _registryMap[registryName]; uint256 version = registry.length; if (version > 0) revert Errors.RegistryNameFound(registryName); if (_reverseRegistry[registryAddress].registryName != 0) { revert Errors.DuplicateRegistryAddress(registryAddress); } // Create an entry in the registry registry.push(registryAddress); _reverseRegistry[registryAddress] = ReverseRegistryData(registryName, version); emit AddRegistry(registryName, registryAddress, version); } /// @inheritdoc IMasterRegistry function updateRegistry(bytes32 registryName, address registryAddress) external override onlyRole(MANAGER_ROLE) { // Check for empty values. if (registryName == 0) revert Errors.NameEmpty(); if (registryAddress == address(0)) revert Errors.AddressEmpty(); // Check that the registry name already exists in the registry. address[] storage registry = _registryMap[registryName]; uint256 version = registry.length; if (version == 0) revert Errors.RegistryNameNotFound(registryName); if (_reverseRegistry[registryAddress].registryName != 0) { revert Errors.DuplicateRegistryAddress(registryAddress); } // Update the entry in the registry registry.push(registryAddress); _reverseRegistry[registryAddress] = ReverseRegistryData(registryName, version); emit UpdateRegistry(registryName, registryAddress, version); } /// @inheritdoc IMasterRegistry function resolveNameToLatestAddress(bytes32 registryName) external view override returns (address) { address[] storage registry = _registryMap[registryName]; uint256 length = registry.length; if (length == 0) revert Errors.RegistryNameNotFound(registryName); return registry[length - 1]; } /// @inheritdoc IMasterRegistry function resolveNameAndVersionToAddress( bytes32 registryName, uint256 version ) external view override returns (address) { address[] storage registry = _registryMap[registryName]; if (version >= registry.length) revert Errors.RegistryNameVersionNotFound(registryName, version); return registry[version]; } /// @inheritdoc IMasterRegistry function resolveNameToAllAddresses(bytes32 registryName) external view override returns (address[] memory) { address[] storage registry = _registryMap[registryName]; if (registry.length == 0) revert Errors.RegistryNameNotFound(registryName); return registry; } /// @inheritdoc IMasterRegistry function resolveAddressToRegistryData(address registryAddress) external view override returns (bytes32 registryName, uint256 version, bool isLatest) { ReverseRegistryData memory data = _reverseRegistry[registryAddress]; if (data.registryName == 0) revert Errors.RegistryAddressNotFound(registryAddress); registryName = data.registryName; version = data.version; uint256 length = _registryMap[registryName].length; isLatest = version == length - 1; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (access/AccessControlEnumerable.sol) pragma solidity ^0.8.0; import "./IAccessControlEnumerable.sol"; import "./AccessControl.sol"; import "../utils/structs/EnumerableSet.sol"; /** * @dev Extension of {AccessControl} that allows enumerating the members of each role. */ abstract contract AccessControlEnumerable is IAccessControlEnumerable, AccessControl { using EnumerableSet for EnumerableSet.AddressSet; mapping(bytes32 => EnumerableSet.AddressSet) private _roleMembers; /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IAccessControlEnumerable).interfaceId || super.supportsInterface(interfaceId); } /** * @dev Returns one of the accounts that have `role`. `index` must be a * value between 0 and {getRoleMemberCount}, non-inclusive. * * Role bearers are not sorted in any particular way, and their ordering may * change at any point. * * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure * you perform all queries on the same block. See the following * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post] * for more information. */ function getRoleMember(bytes32 role, uint256 index) public view virtual override returns (address) { return _roleMembers[role].at(index); } /** * @dev Returns the number of accounts that have `role`. Can be used * together with {getRoleMember} to enumerate all bearers of a role. */ function getRoleMemberCount(bytes32 role) public view virtual override returns (uint256) { return _roleMembers[role].length(); } /** * @dev Overload {_grantRole} to track enumerable memberships */ function _grantRole(bytes32 role, address account) internal virtual override { super._grantRole(role, account); _roleMembers[role].add(account); } /** * @dev Overload {_revokeRole} to track enumerable memberships */ function _revokeRole(bytes32 role, address account) internal virtual override { super._revokeRole(role, account); _roleMembers[role].remove(account); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.5) (utils/Multicall.sol) pragma solidity ^0.8.0; import "./Address.sol"; import "./Context.sol"; /** * @dev Provides a function to batch together multiple calls in a single external call. * * Consider any assumption about calldata validation performed by the sender may be violated if it's not especially * careful about sending transactions invoking {multicall}. For example, a relay address that filters function * selectors won't filter calls nested within a {multicall} operation. * * NOTE: Since 5.0.1 and 4.9.4, this contract identifies non-canonical contexts (i.e. `msg.sender` is not {_msgSender}). * If a non-canonical context is identified, the following self `delegatecall` appends the last bytes of `msg.data` * to the subcall. This makes it safe to use with {ERC2771Context}. Contexts that don't affect the resolution of * {_msgSender} are not propagated to subcalls. * * _Available since v4.1._ */ abstract contract Multicall is Context { /** * @dev Receives and executes a batch of function calls on this contract. * @custom:oz-upgrades-unsafe-allow-reachable delegatecall */ function multicall(bytes[] calldata data) external virtual returns (bytes[] memory results) { bytes memory context = msg.sender == _msgSender() ? new bytes(0) : msg.data[msg.data.length - _contextSuffixLength():]; results = new bytes[](data.length); for (uint256 i = 0; i < data.length; i++) { results[i] = Address.functionDelegateCall(address(this), bytes.concat(data[i], context)); } return results; } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.18; interface IMasterRegistry { /* Structs */ struct ReverseRegistryData { bytes32 registryName; uint256 version; } /* Functions */ /** * @notice Add a new registry entry to the master list. Reverts if an entry is already found with the given name. * @param registryName name for the registry * @param registryAddress address of the new registry */ function addRegistry(bytes32 registryName, address registryAddress) external; /** * @notice Update an existing registry entry to the master list. Reverts if no match is found. * @param registryName name for the registry * @param registryAddress address of the new registry */ function updateRegistry(bytes32 registryName, address registryAddress) external; /** * @notice Resolves a name to the latest registry address. Reverts if no match is found. * @param registryName name for the registry * @return address address of the latest registry with the matching name */ function resolveNameToLatestAddress(bytes32 registryName) external view returns (address); /** * @notice Resolves a name and version to an address. Reverts if there is no registry with given name and version. * @param registryName address of the registry you want to resolve to * @param version version of the registry you want to resolve to */ function resolveNameAndVersionToAddress(bytes32 registryName, uint256 version) external view returns (address); /** * @notice Resolves a name to an array of all addresses. Reverts if no match is found. * @param registryName name for the registry * @return address address of the latest registry with the matching name */ function resolveNameToAllAddresses(bytes32 registryName) external view returns (address[] memory); /** * @notice Resolves an address to registry entry data. * @param registryAddress address of a registry you want to resolve * @return registryName name of the resolved registry * @return version version of the resolved registry * @return isLatest boolean flag of whether the given address is the latest version of the given registries with * matching name */ function resolveAddressToRegistryData(address registryAddress) external view returns (bytes32 registryName, uint256 version, bool isLatest); }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity >=0.8.18; /// @title Errors /// @notice Library containing all custom errors the protocol may revert with. library Errors { //// MASTER REGISTRY //// /// @notice Thrown when the registry name given is empty. error NameEmpty(); /// @notice Thrown when the registry address given is empty. error AddressEmpty(); /// @notice Thrown when the registry name is found when calling addRegistry(). error RegistryNameFound(bytes32 name); /// @notice Thrown when the registry name is not found but is expected to be. error RegistryNameNotFound(bytes32 name); /// @notice Thrown when the registry address is not found but is expected to be. error RegistryAddressNotFound(address registryAddress); /// @notice Thrown when the registry name and version is not found but is expected to be. error RegistryNameVersionNotFound(bytes32 name, uint256 version); /// @notice Thrown when a duplicate registry address is found. error DuplicateRegistryAddress(address registryAddress); //// YEARN STAKING DELEGATE //// /// @notice Error for when an address is zero which is not allowed. error ZeroAddress(); /// @notice Error for when an amount is zero which is not allowed. error ZeroAmount(); /// @notice Error for when a reward split is invalid. error InvalidRewardSplit(); /// @notice Error for when the treasury percentage is too high. error TreasuryPctTooHigh(); /// @notice Error for when perpetual lock is enabled and an action cannot be taken. error PerpetualLockEnabled(); /// @notice Error for when perpetual lock is disabled and an action cannot be taken. error PerpetualLockDisabled(); /// @notice Error for when swap and lock settings are not set. error SwapAndLockNotSet(); /// @notice Error for when gauge rewards have already been added. error GaugeRewardsAlreadyAdded(); /// @notice Error for when gauge rewards have not yet been added. error GaugeRewardsNotYetAdded(); /// @notice Error for when execution of an action is not allowed. error ExecutionNotAllowed(); /// @notice Error for when execution of an action has failed. error ExecutionFailed(); /// @notice Error for when Cove YFI reward forwarder is not set. error CoveYfiRewardForwarderNotSet(); //// STAKING DELEGATE REWARDS //// /// @notice Error for when a rescue operation is not allowed. error RescueNotAllowed(); /// @notice Error for when the previous rewards period has not been completed. error PreviousRewardsPeriodNotCompleted(); /// @notice Error for when only the staking delegate can update a user's balance. error OnlyStakingDelegateCanUpdateUserBalance(); /// @notice Error for when only the staking delegate can add a staking token. error OnlyStakingDelegateCanAddStakingToken(); /// @notice Error for when only the reward distributor can notify the reward amount. error OnlyRewardDistributorCanNotifyRewardAmount(); /// @notice Error for when a staking token has already been added. error StakingTokenAlreadyAdded(); /// @notice Error for when a staking token has not been added. error StakingTokenNotAdded(); /// @notice Error for when the reward rate is too low. error RewardRateTooLow(); /// @notice Error for when the reward duration cannot be zero. error RewardDurationCannotBeZero(); //// WRAPPED STRATEGY CURVE SWAPPER //// /// @notice Error for when slippage is too high. error SlippageTooHigh(); /// @notice Error for when invalid tokens are received. error InvalidTokensReceived(); /// CURVE ROUTER SWAPPER /// /* * @notice Error for when the from token is invalid. * @param intendedFromToken The intended from token address. * @param actualFromToken The actual from token address received. */ error InvalidFromToken(address intendedFromToken, address actualFromToken); /* * @notice Error for when the to token is invalid. * @param intendedToToken The intended to token address. * @param actualToToken The actual to token address received. */ error InvalidToToken(address intendedToToken, address actualToToken); /// @notice Error for when the expected amount is zero. error ExpectedAmountZero(); /// @notice Error for when swap parameters are invalid. error InvalidSwapParams(); /// SWAP AND LOCK /// /// @notice Error for when the same address is used in a context where it is not allowed. error SameAddress(); //// COVEYFI //// /// @notice Error for when only minting is enabled. error OnlyMintingEnabled(); /// RESCUABLE /// /// @notice Error for when an ETH transfer of zero is attempted. error ZeroEthTransfer(); /// @notice Error for when an ETH transfer fails. error EthTransferFailed(); /// @notice Error for when a token transfer of zero is attempted. error ZeroTokenTransfer(); /// GAUGE REWARD RECEIVER /// /// @notice Error for when an action is not authorized. error NotAuthorized(); /// @notice Error for when rescuing a reward token is not allowed. error CannotRescueRewardToken(); /// DYFI REDEEMER /// /// @notice Error for when an array length is invalid. error InvalidArrayLength(); /// @notice Error for when a price feed is outdated. error PriceFeedOutdated(); /// @notice Error for when a price feed round is incorrect. error PriceFeedIncorrectRound(); /// @notice Error for when a price feed returns a zero price. error PriceFeedReturnedZeroPrice(); /// @notice Error for when there is no DYFI to redeem. error NoDYfiToRedeem(); /// @notice Error for when an ETH transfer for caller reward fails. error CallerRewardEthTransferFailed(); /// COVE YEARN GAUGE FACTORY /// /// @notice Error for when a gauge has already been deployed. error GaugeAlreadyDeployed(); /// @notice Error for when a gauge has not been deployed. error GaugeNotDeployed(); /// MINICHEF V3 //// /// @notice Error for when an LP token is invalid. error InvalidLPToken(); /// @notice Error for when an LP token has not been added. error LPTokenNotAdded(); /// @notice Error for when an LP token does not match the pool ID. error LPTokenDoesNotMatchPoolId(); /// @notice Error for when there is an insufficient balance. error InsufficientBalance(); /// @notice Error for when an LP token has already been added. error LPTokenAlreadyAdded(); /// @notice Error for when the reward rate is too high. error RewardRateTooHigh(); /// Yearn4626RouterExt /// /// @notice Error for when there are insufficient shares. error InsufficientShares(); /// @notice Error for when the 'to' address is invalid. error InvalidTo(); /// @notice Error esure the has enough remaining gas. error InsufficientGas(); /// TESTING /// /// @notice Error for when there is not enough balance to take away. error TakeAwayNotEnoughBalance(); /// @notice Error for when a strategy has not been added to a vault. error StrategyNotAddedToVault(); /// COVE TOKEN /// /// @notice Error for when a transfer is attempted before it is allowed. error TransferNotAllowedYet(); /// @notice Error for when an address is being added as both a sender and a receiver. error CannotBeBothSenderAndReceiver(); /// @notice Error for when an unpause is attempted too early. error UnpauseTooEarly(); /// @notice Error for when the pause period is too long. error PausePeriodTooLong(); /// @notice Error for when minting is attempted too early. error MintingAllowedTooEarly(); /// @notice Error for when the mint amount exceeds the cap. error InflationTooLarge(); /* * @notice Error for when an unauthorized account attempts an action requiring a specific role. * @param account The account attempting the unauthorized action. * @param neededRole The role required for the action. */ error AccessControlEnumerableUnauthorizedAccount(address account, bytes32 neededRole); /// @notice Error for when an action is unauthorized. error Unauthorized(); /// @notice Error for when a pause is expected but not enacted. error ExpectedPause(); /// COVE YEARN GAUGE FACTORY /// /// @notice Error for when an address is not a contract. error AddressNotContract(); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (access/IAccessControlEnumerable.sol) pragma solidity ^0.8.0; import "./IAccessControl.sol"; /** * @dev External interface of AccessControlEnumerable declared to support ERC165 detection. */ interface IAccessControlEnumerable is IAccessControl { /** * @dev Returns one of the accounts that have `role`. `index` must be a * value between 0 and {getRoleMemberCount}, non-inclusive. * * Role bearers are not sorted in any particular way, and their ordering may * change at any point. * * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure * you perform all queries on the same block. See the following * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post] * for more information. */ function getRoleMember(bytes32 role, uint256 index) external view returns (address); /** * @dev Returns the number of accounts that have `role`. Can be used * together with {getRoleMember} to enumerate all bearers of a role. */ function getRoleMemberCount(bytes32 role) external view returns (uint256); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (access/AccessControl.sol) pragma solidity ^0.8.0; import "./IAccessControl.sol"; import "../utils/Context.sol"; import "../utils/Strings.sol"; import "../utils/introspection/ERC165.sol"; /** * @dev Contract module that allows children to implement role-based access * control mechanisms. This is a lightweight version that doesn't allow enumerating role * members except through off-chain means by accessing the contract event logs. Some * applications may benefit from on-chain enumerability, for those cases see * {AccessControlEnumerable}. * * Roles are referred to by their `bytes32` identifier. These should be exposed * in the external API and be unique. The best way to achieve this is by * using `public constant` hash digests: * * ```solidity * bytes32 public constant MY_ROLE = keccak256("MY_ROLE"); * ``` * * Roles can be used to represent a set of permissions. To restrict access to a * function call, use {hasRole}: * * ```solidity * function foo() public { * require(hasRole(MY_ROLE, msg.sender)); * ... * } * ``` * * Roles can be granted and revoked dynamically via the {grantRole} and * {revokeRole} functions. Each role has an associated admin role, and only * accounts that have a role's admin role can call {grantRole} and {revokeRole}. * * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means * that only accounts with this role will be able to grant or revoke other * roles. More complex role relationships can be created by using * {_setRoleAdmin}. * * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to * grant and revoke this role. Extra precautions should be taken to secure * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules} * to enforce additional security measures for this role. */ abstract contract AccessControl is Context, IAccessControl, ERC165 { struct RoleData { mapping(address => bool) members; bytes32 adminRole; } mapping(bytes32 => RoleData) private _roles; bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00; /** * @dev Modifier that checks that an account has a specific role. Reverts * with a standardized message including the required role. * * The format of the revert reason is given by the following regular expression: * * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/ * * _Available since v4.1._ */ modifier onlyRole(bytes32 role) { _checkRole(role); _; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId); } /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes32 role, address account) public view virtual override returns (bool) { return _roles[role].members[account]; } /** * @dev Revert with a standard message if `_msgSender()` is missing `role`. * Overriding this function changes the behavior of the {onlyRole} modifier. * * Format of the revert message is described in {_checkRole}. * * _Available since v4.6._ */ function _checkRole(bytes32 role) internal view virtual { _checkRole(role, _msgSender()); } /** * @dev Revert with a standard message if `account` is missing `role`. * * The format of the revert reason is given by the following regular expression: * * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/ */ function _checkRole(bytes32 role, address account) internal view virtual { if (!hasRole(role, account)) { revert( string( abi.encodePacked( "AccessControl: account ", Strings.toHexString(account), " is missing role ", Strings.toHexString(uint256(role), 32) ) ) ); } } /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {_setRoleAdmin}. */ function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) { return _roles[role].adminRole; } /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. * * May emit a {RoleGranted} event. */ function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) { _grantRole(role, account); } /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. * * May emit a {RoleRevoked} event. */ function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) { _revokeRole(role, account); } /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been revoked `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. * * May emit a {RoleRevoked} event. */ function renounceRole(bytes32 role, address account) public virtual override { require(account == _msgSender(), "AccessControl: can only renounce roles for self"); _revokeRole(role, account); } /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. Note that unlike {grantRole}, this function doesn't perform any * checks on the calling account. * * May emit a {RoleGranted} event. * * [WARNING] * ==== * This function should only be called from the constructor when setting * up the initial roles for the system. * * Using this function in any other way is effectively circumventing the admin * system imposed by {AccessControl}. * ==== * * NOTE: This function is deprecated in favor of {_grantRole}. */ function _setupRole(bytes32 role, address account) internal virtual { _grantRole(role, account); } /** * @dev Sets `adminRole` as ``role``'s admin role. * * Emits a {RoleAdminChanged} event. */ function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual { bytes32 previousAdminRole = getRoleAdmin(role); _roles[role].adminRole = adminRole; emit RoleAdminChanged(role, previousAdminRole, adminRole); } /** * @dev Grants `role` to `account`. * * Internal function without access restriction. * * May emit a {RoleGranted} event. */ function _grantRole(bytes32 role, address account) internal virtual { if (!hasRole(role, account)) { _roles[role].members[account] = true; emit RoleGranted(role, account, _msgSender()); } } /** * @dev Revokes `role` from `account`. * * Internal function without access restriction. * * May emit a {RoleRevoked} event. */ function _revokeRole(bytes32 role, address account) internal virtual { if (hasRole(role, account)) { _roles[role].members[account] = false; emit RoleRevoked(role, account, _msgSender()); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/structs/EnumerableSet.sol) // This file was procedurally generated from scripts/generate/templates/EnumerableSet.js. 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. * * ```solidity * 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. * * [WARNING] * ==== * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure * unusable. * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info. * * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an * array of EnumerableSet. * ==== */ 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) { bytes32[] memory store = _values(set._inner); bytes32[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } // 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; /// @solidity memory-safe-assembly 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 in 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; /// @solidity memory-safe-assembly assembly { result := store } return result; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * * Furthermore, `isContract` will also return true if the target contract within * the same transaction is already scheduled for destruction by `SELFDESTRUCT`, * which only has an effect at the end of a transaction. * ==== * * [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://consensys.net/diligence/blog/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.8.0/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 functionCallWithValue(target, data, 0, "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"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, 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) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or 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 { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // 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 /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } function _contextSuffixLength() internal view virtual returns (uint256) { return 0; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol) pragma solidity ^0.8.0; /** * @dev External interface of AccessControl declared to support ERC165 detection. */ interface IAccessControl { /** * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` * * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite * {RoleAdminChanged} not being emitted signaling this. * * _Available since v3.1._ */ event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole); /** * @dev Emitted when `account` is granted `role`. * * `sender` is the account that originated the contract call, an admin role * bearer except when using {AccessControl-_setupRole}. */ event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Emitted when `account` is revoked `role`. * * `sender` is the account that originated the contract call: * - if using `revokeRole`, it is the admin role bearer * - if using `renounceRole`, it is the role bearer (i.e. `account`) */ event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes32 role, address account) external view returns (bool); /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {AccessControl-_setRoleAdmin}. */ function getRoleAdmin(bytes32 role) external view returns (bytes32); /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function grantRole(bytes32 role, address account) external; /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function revokeRole(bytes32 role, address account) external; /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been granted `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. */ function renounceRole(bytes32 role, address account) external; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol) pragma solidity ^0.8.0; import "./math/Math.sol"; import "./math/SignedMath.sol"; /** * @dev String operations. */ library Strings { bytes16 private constant _SYMBOLS = "0123456789abcdef"; uint8 private constant _ADDRESS_LENGTH = 20; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; /// @solidity memory-safe-assembly assembly { ptr := add(buffer, add(32, length)) } while (true) { ptr--; /// @solidity memory-safe-assembly assembly { mstore8(ptr, byte(mod(value, 10), _SYMBOLS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `int256` to its ASCII `string` decimal representation. */ function toString(int256 value) internal pure returns (string memory) { return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value)))); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); } /** * @dev Returns true if the two strings are equal. */ function equal(string memory a, string memory b) internal pure returns (bool) { return keccak256(bytes(a)) == keccak256(bytes(b)); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) pragma solidity ^0.8.0; import "./IERC165.sol"; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol) pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { enum Rounding { Down, // Toward negative infinity Up, // Toward infinity Zero // Toward zero } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a > b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) * with further edits by Uniswap Labs also under MIT license. */ function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { // Solidity will revert if denominator == 0, unlike the div opcode on its own. // The surrounding unchecked block does not change this fact. // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic. return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1, "Math: mulDiv overflow"); /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1. // See https://cs.stackexchange.com/q/138556/92363. // Does not overflow because the denominator cannot be zero at this stage in the function. uint256 twos = denominator & (~denominator + 1); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv = 1 mod 2^4. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works // in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2^8 inverse *= 2 - denominator * inverse; // inverse mod 2^16 inverse *= 2 - denominator * inverse; // inverse mod 2^32 inverse *= 2 - denominator * inverse; // inverse mod 2^64 inverse *= 2 - denominator * inverse; // inverse mod 2^128 inverse *= 2 - denominator * inverse; // inverse mod 2^256 // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inverse; return result; } } /** * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) { uint256 result = mulDiv(x, y, denominator); if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) { result += 1; } return result; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down. * * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). */ function sqrt(uint256 a) internal pure returns (uint256) { if (a == 0) { return 0; } // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. // // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`. // // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)` // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)` // // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1 << (log2(a) >> 1); // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision // into the expected uint128 result. unchecked { result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; return min(result, a / result); } } /** * @notice Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + (rounding == Rounding.Up && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2, rounded down, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 128; } if (value >> 64 > 0) { value >>= 64; result += 64; } if (value >> 32 > 0) { value >>= 32; result += 32; } if (value >> 16 > 0) { value >>= 16; result += 16; } if (value >> 8 > 0) { value >>= 8; result += 8; } if (value >> 4 > 0) { value >>= 4; result += 4; } if (value >> 2 > 0) { value >>= 2; result += 2; } if (value >> 1 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10, rounded down, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >= 10 ** 64) { value /= 10 ** 64; result += 64; } if (value >= 10 ** 32) { value /= 10 ** 32; result += 32; } if (value >= 10 ** 16) { value /= 10 ** 16; result += 16; } if (value >= 10 ** 8) { value /= 10 ** 8; result += 8; } if (value >= 10 ** 4) { value /= 10 ** 4; result += 4; } if (value >= 10 ** 2) { value /= 10 ** 2; result += 2; } if (value >= 10 ** 1) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0); } } /** * @dev Return the log in base 256, rounded down, of a positive value. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ function log256(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 16; } if (value >> 64 > 0) { value >>= 64; result += 8; } if (value >> 32 > 0) { value >>= 32; result += 4; } if (value >> 16 > 0) { value >>= 16; result += 2; } if (value >> 8 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 256, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol) pragma solidity ^0.8.0; /** * @dev Standard signed math utilities missing in the Solidity language. */ library SignedMath { /** * @dev Returns the largest of two signed numbers. */ function max(int256 a, int256 b) internal pure returns (int256) { return a > b ? a : b; } /** * @dev Returns the smallest of two signed numbers. */ function min(int256 a, int256 b) internal pure returns (int256) { return a < b ? a : b; } /** * @dev Returns the average of two signed numbers without overflow. * The result is rounded towards zero. */ function average(int256 a, int256 b) internal pure returns (int256) { // Formula from the book "Hacker's Delight" int256 x = (a & b) + ((a ^ b) >> 1); return x + (int256(uint256(x) >> 255) & (a ^ b)); } /** * @dev Returns the absolute unsigned value of a signed value. */ function abs(int256 n) internal pure returns (uint256) { unchecked { // must be unchecked in order to support `n = type(int256).min` return uint256(n >= 0 ? n : -n); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); }
{ "remappings": [ "@openzeppelin/=lib/openzeppelin-contracts/", "@openzeppelin-upgradeable/=lib/openzeppelin-contracts-upgradeable/", "tokenized-strategy/=lib/tokenized-strategy/src/", "yearn-vaults-v3/=lib/yearn-vaults-v3/contracts/", "Yearn-ERC4626-Router/=lib/Yearn-ERC4626-Router/src/", "solmate/=lib/permit2/lib/solmate/src/", "permit2/=lib/permit2/src/", "forge-std/=lib/forge-std/src/", "ds-test/=lib/forge-std/lib/ds-test/src/", "@crytic/properties/=lib/properties/", "forge-deploy/=lib/forge-deploy/contracts/", "script/=script/", "src/=src/", "test/=test/" ], "optimizer": { "enabled": true, "runs": 200 }, "metadata": { "useLiteralContent": false, "bytecodeHash": "ipfs", "appendCBOR": true }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "evmVersion": "paris", "viaIR": false, "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"admin","type":"address"},{"internalType":"address","name":"manager","type":"address"}],"stateMutability":"payable","type":"constructor"},{"inputs":[],"name":"AddressEmpty","type":"error"},{"inputs":[{"internalType":"address","name":"registryAddress","type":"address"}],"name":"DuplicateRegistryAddress","type":"error"},{"inputs":[],"name":"NameEmpty","type":"error"},{"inputs":[{"internalType":"address","name":"registryAddress","type":"address"}],"name":"RegistryAddressNotFound","type":"error"},{"inputs":[{"internalType":"bytes32","name":"name","type":"bytes32"}],"name":"RegistryNameFound","type":"error"},{"inputs":[{"internalType":"bytes32","name":"name","type":"bytes32"}],"name":"RegistryNameNotFound","type":"error"},{"inputs":[{"internalType":"bytes32","name":"name","type":"bytes32"},{"internalType":"uint256","name":"version","type":"uint256"}],"name":"RegistryNameVersionNotFound","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"name","type":"bytes32"},{"indexed":false,"internalType":"address","name":"registryAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"version","type":"uint256"}],"name":"AddRegistry","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"name","type":"bytes32"},{"indexed":false,"internalType":"address","name":"registryAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"version","type":"uint256"}],"name":"UpdateRegistry","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"registryName","type":"bytes32"},{"internalType":"address","name":"registryAddress","type":"address"}],"name":"addRegistry","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getRoleMember","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMemberCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"multicall","outputs":[{"internalType":"bytes[]","name":"results","type":"bytes[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"registryAddress","type":"address"}],"name":"resolveAddressToRegistryData","outputs":[{"internalType":"bytes32","name":"registryName","type":"bytes32"},{"internalType":"uint256","name":"version","type":"uint256"},{"internalType":"bool","name":"isLatest","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"registryName","type":"bytes32"},{"internalType":"uint256","name":"version","type":"uint256"}],"name":"resolveNameAndVersionToAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"registryName","type":"bytes32"}],"name":"resolveNameToAllAddresses","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"registryName","type":"bytes32"}],"name":"resolveNameToLatestAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"registryName","type":"bytes32"},{"internalType":"address","name":"registryAddress","type":"address"}],"name":"updateRegistry","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
0000000000000000000000007bd578354b0b2f02e656f1bdc0e41a80f860534b0000000000000000000000008842fe65a7db9bb5de6d50e49af19496da09f9b5
-----Decoded View---------------
Arg [0] : admin (address): 0x7Bd578354b0B2f02E656f1bDC0e41a80f860534b
Arg [1] : manager (address): 0x8842fe65A7Db9BB5De6d50e49aF19496da09F9b5
-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000007bd578354b0b2f02e656f1bdc0e41a80f860534b
Arg [1] : 0000000000000000000000008842fe65a7db9bb5de6d50e49af19496da09f9b5
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 31 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.