Description:
Proxy contract enabling upgradeable smart contract patterns. Delegates calls to an implementation contract.
Blockchain: Ethereum
Source Code: View Code On The Blockchain
Solidity Source Code:
// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.8.0 ^0.8.19;
// lib/euler-vault-kit/src/GenericFactory/BeaconProxy.sol
/// @title BeaconProxy
/// @custom:security-contact security@euler.xyz
/// @author Euler Labs (https://www.eulerlabs.com/)
/// @notice A proxy contract, forwarding all calls to an implementation contract, fetched from a beacon
/// @dev The proxy attaches up to 128 bytes of metadata to the delegated call data.
contract BeaconProxy {
// ERC-1967 beacon address slot. bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)
bytes32 internal constant BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
// Beacon implementation() selector
bytes32 internal constant IMPLEMENTATION_SELECTOR =
0x5c60da1b00000000000000000000000000000000000000000000000000000000;
// Max trailing data length, 4 immutable slots
uint256 internal constant MAX_TRAILING_DATA_LENGTH = 128;
address internal immutable beacon;
uint256 internal immutable metadataLength;
bytes32 internal immutable metadata0;
bytes32 internal immutable metadata1;
bytes32 internal immutable metadata2;
bytes32 internal immutable metadata3;
event Genesis();
constructor(bytes memory trailingData) {
emit Genesis();
require(trailingData.length <= MAX_TRAILING_DATA_LENGTH, "trailing data too long");
// Beacon is always the proxy creator; store it in immutable
beacon = msg.sender;
// Store the beacon address in ERC-1967 slot for compatibility with block explorers
assembly {
sstore(BEACON_SLOT, caller())
}
// Record length as immutable
metadataLength = trailingData.length;
// Pad length with uninitialized memory so the decode will succeed
assembly {
mstore(trailingData, MAX_TRAILING_DATA_LENGTH)
}
(metadata0, metadata1, metadata2, metadata3) = abi.decode(trailingData, (bytes32, bytes32, bytes32, bytes32));
}
fallback() external payable {
address beacon_ = beacon;
uint256 metadataLength_ = metadataLength;
bytes32 metadata0_ = metadata0;
bytes32 metadata1_ = metadata1;
bytes32 metadata2_ = metadata2;
bytes32 metadata3_ = metadata3;
assembly {
// Fetch implementation address from the beacon
mstore(0, IMPLEMENTATION_SELECTOR)
// Implementation call is trusted not to revert and to return an address
let result := staticcall(gas(), beacon_, 0, 4, 0, 32)
let implementation := mload(0)
// delegatecall to the implementation with trailing metadata
calldatacopy(0, 0, calldatasize())
mstore(calldatasize(), metadata0_)
mstore(add(32, calldatasize()), metadata1_)
mstore(add(64, calldatasize()), metadata2_)
mstore(add(96, calldatasize()), metadata3_)
result := delegatecall(gas(), implementation, 0, add(metadataLength_, calldatasize()), 0, 0)
returndatacopy(0, 0, returndatasize())
switch result
case 0 { revert(0, returndatasize()) }
default { return(0, returndatasize()) }
}
}
}
// lib/openzeppelin-contracts/contracts/utils/structs/EnumerableSet.sol
// OpenZeppelin Contracts (last updated v5.1.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.
/**
* @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 is the index of the value in the `values` array plus 1.
// Position 0 is used to mean a value is not in the set.
mapping(bytes32 value => uint256) _positions;
}
/**
* @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._positions[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 cache the value's position to prevent multiple reads from the same storage slot
uint256 position = set._positions[value];
if (position != 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 valueIndex = position - 1;
uint256 lastIndex = set._values.length - 1;
if (valueIndex != lastIndex) {
bytes32 lastValue = set._values[lastIndex];
// Move the lastValue to the index where the value to delete is
set._values[valueIndex] = lastValue;
// Update the tracked position of the lastValue (that was just moved)
set._positions[lastValue] = position;
}
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the tracked position for the deleted slot
delete set._positions[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._positions[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;
assembly ("memory-safe") {
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;
assembly ("memory-safe") {
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;
assembly ("memory-safe") {
result := store
}
return result;
}
}
// lib/ethereum-vault-connector/src/ExecutionContext.sol
type EC is uint256;
/// @title ExecutionContext
/// @custom:security-contact security@euler.xyz
/// @author Euler Labs (https://www.eulerlabs.com/)
/// @notice This library provides functions for managing the execution context in the Ethereum Vault Connector.
/// @dev The execution context is a bit field that stores the following information:
/// @dev - on behalf of account - an account on behalf of which the currently executed operation is being performed
/// @dev - checks deferred flag - used to indicate whether checks are deferred
/// @dev - checks in progress flag - used to indicate that the account/vault status checks are in progress. This flag is
/// used to prevent re-entrancy.
/// @dev - control collateral in progress flag - used to indicate that the control collateral is in progress. This flag
/// is used to prevent re-entrancy.
/// @dev - operator authenticated flag - used to indicate that the currently executed operation is being performed by
/// the account operator
/// @dev - simulation flag - used to indicate that the currently executed batch call is a simulation
/// @dev - stamp - dummy value for optimization purposes
library ExecutionContext {
uint256 internal constant ON_BEHALF_OF_ACCOUNT_MASK =
0x000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
uint256 internal constant CHECKS_DEFERRED_MASK = 0x0000000000000000000000FF0000000000000000000000000000000000000000;
uint256 internal constant CHECKS_IN_PROGRESS_MASK =
0x00000000000000000000FF000000000000000000000000000000000000000000;
uint256 internal constant CONTROL_COLLATERAL_IN_PROGRESS_LOCK_MASK =
0x000000000000000000FF00000000000000000000000000000000000000000000;
uint256 internal constant OPERATOR_AUTHENTICATED_MASK =
0x0000000000000000FF0000000000000000000000000000000000000000000000;
uint256 internal constant SIMULATION_MASK = 0x00000000000000FF000000000000000000000000000000000000000000000000;
uint256 internal constant STAMP_OFFSET = 200;
// None of the functions below modifies the state. All the functions operate on the copy
// of the execution context and return its modified value as a result. In order to update
// one should use the result of the function call as a new execution context value.
function getOnBehalfOfAccount(EC self) internal pure returns (address result) {
result = address(uint160(EC.unwrap(self) & ON_BEHALF_OF_ACCOUNT_MASK));
}
function setOnBehalfOfAccount(EC self, address account) internal pure returns (EC result) {
result = EC.wrap((EC.unwrap(self) & ~ON_BEHALF_OF_ACCOUNT_MASK) | uint160(account));
}
function areChecksDeferred(EC self) internal pure returns (bool result) {
result = EC.unwrap(self) & CHECKS_DEFERRED_MASK != 0;
}
function setChecksDeferred(EC self) internal pure returns (EC result) {
result = EC.wrap(EC.unwrap(self) | CHECKS_DEFERRED_MASK);
}
function areChecksInProgress(EC self) internal pure returns (bool result) {
result = EC.unwrap(self) & CHECKS_IN_PROGRESS_MASK != 0;
}
function setChecksInProgress(EC self) internal pure returns (EC result) {
result = EC.wrap(EC.unwrap(self) | CHECKS_IN_PROGRESS_MASK);
}
function isControlCollateralInProgress(EC self) internal pure returns (bool result) {
result = EC.unwrap(self) & CONTROL_COLLATERAL_IN_PROGRESS_LOCK_MASK != 0;
}
function setControlCollateralInProgress(EC self) internal pure returns (EC result) {
result = EC.wrap(EC.unwrap(self) | CONTROL_COLLATERAL_IN_PROGRESS_LOCK_MASK);
}
function isOperatorAuthenticated(EC self) internal pure returns (bool result) {
result = EC.unwrap(self) & OPERATOR_AUTHENTICATED_MASK != 0;
}
function setOperatorAuthenticated(EC self) internal pure returns (EC result) {
result = EC.wrap(EC.unwrap(self) | OPERATOR_AUTHENTICATED_MASK);
}
function clearOperatorAuthenticated(EC self) internal pure returns (EC result) {
result = EC.wrap(EC.unwrap(self) & ~OPERATOR_AUTHENTICATED_MASK);
}
function isSimulationInProgress(EC self) internal pure returns (bool result) {
result = EC.unwrap(self) & SIMULATION_MASK != 0;
}
function setSimulationInProgress(EC self) internal pure returns (EC result) {
result = EC.wrap(EC.unwrap(self) | SIMULATION_MASK);
}
}
// lib/openzeppelin-contracts/contracts/access/IAccessControl.sol
// OpenZeppelin Contracts (last updated v5.1.0) (access/IAccessControl.sol)
/**
* @dev External interface of AccessControl declared to support ERC-165 detection.
*/
interface IAccessControl {
/**
* @dev The `account` is missing a role.
*/
error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);
/**
* @dev The caller of a function is not the expected one.
*
* NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.
*/
error AccessControlBadConfirmation();
/**
* @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.
*/
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. This account bears the admin role (for the granted role).
* Expected in cases where the role was granted using the internal {AccessControl-_grantRole}.
*/
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 `callerConfirmation`.
*/
function renounceRole(bytes32 role, address callerConfirmation) external;
}
// lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol
// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)
/**
* @dev Interface of the ERC-165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[ERC].
*
* 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[ERC 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);
}
// lib/ethereum-vault-connector/src/interfaces/IEthereumVaultConnector.sol
/// @title IEVC
/// @custom:security-contact security@euler.xyz
/// @author Euler Labs (https://www.eulerlabs.com/)
/// @notice This interface defines the methods for the Ethereum Vault Connector.
interface IEVC {
/// @notice A struct representing a batch item.
/// @dev Each batch item represents a single operation to be performed within a checks deferred context.
struct BatchItem {
/// @notice The target contract to be called.
address targetContract;
/// @notice The account on behalf of which the operation is to be performed. msg.sender must be authorized to
/// act on behalf of this account. Must be address(0) if the target contract is the EVC itself.
address onBehalfOfAccount;
/// @notice The amount of value to be forwarded with the call. If the value is type(uint256).max, the whole
/// balance of the EVC contract will be forwarded. Must be 0 if the target contract is the EVC itself.
uint256 value;
/// @notice The encoded data which is called on the target contract.
bytes data;
}
/// @notice A struct representing the result of a batch item operation.
/// @dev Used only for simulation purposes.
struct BatchItemResult {
/// @notice A boolean indicating whether the operation was successful.
bool success;
/// @notice The result of the operation.
bytes result;
}
/// @notice A struct representing the result of the account or vault status check.
/// @dev Used only for simulation purposes.
struct StatusCheckResult {
/// @notice The address of the account or vault for which the check was performed.
address checkedAddress;
/// @notice A boolean indicating whether the status of the account or vault is valid.
bool isValid;
/// @notice The result of the check.
bytes result;
}
/// @notice Returns current raw execution context.
/// @dev When checks in progress, on behalf of account is always address(0).
/// @return context Current raw execution context.
function getRawExecutionContext() external view returns (uint256 context);
/// @notice Returns an account on behalf of which the operation is being executed at the moment and whether the
/// controllerToCheck is an enabled controller for that account.
/// @dev This function should only be used by external smart contracts if msg.sender is the EVC. Otherwise, the
/// account address returned must not be trusted.
/// @dev When checks in progress, on behalf of account is always address(0). When address is zero, the function
/// reverts to protect the consumer from ever relying on the on behalf of account address which is in its default
/// state.
/// @param controllerToCheck The address of the controller for which it is checked whether it is an enabled
/// controller for the account on behalf of which the operation is being executed at the moment.
/// @return onBehalfOfAccount An account that has been authenticated and on behalf of which the operation is being
/// executed at the moment.
/// @return controllerEnabled A boolean value that indicates whether controllerToCheck is an enabled controller for
/// the account on behalf of which the operation is being executed at the moment. Always false if controllerToCheck
/// is address(0).
function getCurrentOnBehalfOfAccount(address controllerToCheck)
external
view
returns (address onBehalfOfAccount, bool controllerEnabled);
/// @notice Checks if checks are deferred.
/// @return A boolean indicating whether checks are deferred.
function areChecksDeferred() external view returns (bool);
/// @notice Checks if checks are in progress.
/// @return A boolean indicating whether checks are in progress.
function areChecksInProgress() external view returns (bool);
/// @notice Checks if control collateral is in progress.
/// @return A boolean indicating whether control collateral is in progress.
function isControlCollateralInProgress() external view returns (bool);
/// @notice Checks if an operator is authenticated.
/// @return A boolean indicating whether an operator is authenticated.
function isOperatorAuthenticated() external view returns (bool);
/// @notice Checks if a simulation is in progress.
/// @return A boolean indicating whether a simulation is in progress.
function isSimulationInProgress() external view returns (bool);
/// @notice Checks whether the specified account and the other account have the same owner.
/// @dev The function is used to check whether one account is authorized to perform operations on behalf of the
/// other. Accounts are considered to have a common owner if they share the first 19 bytes of their address.
/// @param account The address of the account that is being checked.
/// @param otherAccount The address of the other account that is being checked.
/// @return A boolean flag that indicates whether the accounts have the same owner.
function haveCommonOwner(address account, address otherAccount) external pure returns (bool);
/// @notice Returns the address prefix of the specified account.
/// @dev The address prefix is the first 19 bytes of the account address.
/// @param account The address of the account whose address prefix is being retrieved.
/// @return A bytes19 value that represents the address prefix of the account.
function getAddressPrefix(address account) external pure returns (bytes19);
/// @notice Returns the owner for the specified account.
/// @dev The function returns address(0) if the owner is not registered. Registration of the owner happens on the
/// initial
/// interaction with the EVC that requires authentication of an owner.
/// @param account The address of the account whose owner is being retrieved.
/// @return owner The address of the account owner. An account owner is an EOA/smart contract which address matches
/// the first 19 bytes of the account address.
function getAccountOwner(address account) external view returns (address);
/// @notice Checks if lockdown mode is enabled for a given address prefix.
/// @param addressPrefix The address prefix to check for lockdown mode status.
/// @return A boolean indicating whether lockdown mode is enabled.
function isLockdownMode(bytes19 addressPrefix) external view returns (bool);
/// @notice Checks if permit functionality is disabled for a given address prefix.
/// @param addressPrefix The address prefix to check for permit functionality status.
/// @return A boolean indicating whether permit functionality is disabled.
function isPermitDisabledMode(bytes19 addressPrefix) external view returns (bool);
/// @notice Returns the current nonce for a given address prefix and nonce namespace.
/// @dev Each nonce namespace provides 256 bit nonce that has to be used sequentially. There's no requirement to use
/// all the nonces for a given nonce namespace before moving to the next one which allows to use permit messages in
/// a non-sequential manner.
/// @param addressPrefix The address prefix for which the nonce is being retrieved.
/// @param nonceNamespace The nonce namespace for which the nonce is being retrieved.
/// @return nonce The current nonce for the given address prefix and nonce namespace.
function getNonce(bytes19 addressPrefix, uint256 nonceNamespace) external view returns (uint256 nonce);
/// @notice Returns the bit field for a given address prefix and operator.
/// @dev The bit field is used to store information about authorized operators for a given address prefix. Each bit
/// in the bit field corresponds to one account belonging to the same owner. If the bit is set, the operator is
/// authorized for the account.
/// @param addressPrefix The address prefix for which the bit field is being retrieved.
/// @param operator The address of the operator for which the bit field is being retrieved.
/// @return operatorBitField The bit field for the given address prefix and operator. The bit field defines which
/// accounts the operator is authorized for. It is a 256-position binary array like 0...010...0, marking the account
/// positionally in a uint256. The position in the bit field corresponds to the account ID (0-255), where 0 is the
/// owner account's ID.
function getOperator(bytes19 addressPrefix, address operator) external view returns (uint256 operatorBitField);
/// @notice Returns whether a given operator has been authorized for a given account.
/// @param account The address of the account whose operator is being checked.
/// @param operator The address of the operator that is being checked.
/// @return authorized A boolean value that indicates whether the operator is authorized for the account.
function isAccountOperatorAuthorized(address account, address operator) external view returns (bool authorized);
/// @notice Enables or disables lockdown mode for a given address prefix.
/// @dev This function can only be called by the owner of the address prefix. To disable this mode, the EVC
/// must be called directly. It is not possible to disable this mode by using checks-deferrable call or
/// permit message.
/// @param addressPrefix The address prefix for which the lockdown mode is being set.
/// @param enabled A boolean indicating whether to enable or disable lockdown mode.
function setLockdownMode(bytes19 addressPrefix, bool enabled) external payable;
/// @notice Enables or disables permit functionality for a given address prefix.
/// @dev This function can only be called by the owner of the address prefix. To disable this mode, the EVC
/// must be called directly. It is not possible to disable this mode by using checks-deferrable call or (by
/// definition) permit message. To support permit functionality by default, note that the logic was inverted here. To
/// disable the permit functionality, one must pass true as the second argument. To enable the permit
/// functionality, one must pass false as the second argument.
/// @param addressPrefix The address prefix for which the permit functionality is being set.
/// @param enabled A boolean indicating whether to enable or disable the disable-permit mode.
function setPermitDisabledMode(bytes19 addressPrefix, bool enabled) external payable;
/// @notice Sets the nonce for a given address prefix and nonce namespace.
/// @dev This function can only be called by the owner of the address prefix. Each nonce namespace provides a 256
/// bit nonce that has to be used sequentially. There's no requirement to use all the nonces for a given nonce
/// namespace before moving to the next one which allows the use of permit messages in a non-sequential manner. To
/// invalidate signed permit messages, set the nonce for a given nonce namespace accordingly. To invalidate all the
/// permit messages for a given nonce namespace, set the nonce to type(uint).max.
/// @param addressPrefix The address prefix for which the nonce is being set.
/// @param nonceNamespace The nonce namespace for which the nonce is being set.
/// @param nonce The new nonce for the given address prefix and nonce namespace.
function setNonce(bytes19 addressPrefix, uint256 nonceNamespace, uint256 nonce) external payable;
/// @notice Sets the bit field for a given address prefix and operator.
/// @dev This function can only be called by the owner of the address prefix. Each bit in the bit field corresponds
/// to one account belonging to the same owner. If the bit is set, the operator is authorized for the account.
/// @param addressPrefix The address prefix for which the bit field is being set.
/// @param operator The address of the operator for which the bit field is being set. Can neither be the EVC address
/// nor an address belonging to the same address prefix.
/// @param operatorBitField The new bit field for the given address prefix and operator. Reverts if the provided
/// value is equal to the currently stored value.
function setOperator(bytes19 addressPrefix, address operator, uint256 operatorBitField) external payable;
/// @notice Authorizes or deauthorizes an operator for the account.
/// @dev Only the owner or authorized operator of the account can call this function. An operator is an address that
/// can perform actions for an account on behalf of the owner. If it's an operator calling this function, it can
/// only deauthorize itself.
/// @param account The address of the account whose operator is being set or unset.
/// @param operator The address of the operator that is being installed or uninstalled. Can neither be the EVC
/// address nor an address belonging to the same owner as the account.
/// @param authorized A boolean value that indicates whether the operator is being authorized or deauthorized.
/// Reverts if the provided value is equal to the currently stored value.
function setAccountOperator(address account, address operator, bool authorized) external payable;
/// @notice Returns an array of collaterals enabled for an account.
/// @dev A collateral is a vault for which an account's balances are under the control of the currently enabled
/// controller vault.
/// @param account The address of the account whose collaterals are being queried.
/// @return An array of addresses that are enabled collaterals for the account.
function getCollaterals(address account) external view returns (address[] memory);
/// @notice Returns whether a collateral is enabled for an account.
/// @dev A collateral is a vault for which account's balances are under the control of the currently enabled
/// controller vault.
/// @param account The address of the account that is being checked.
/// @param vault The address of the collateral that is being checked.
/// @return A boolean value that indicates whether the vault is an enabled collateral for the account or not.
function isCollateralEnabled(address account, address vault) external view returns (bool);
/// @notice Enables a collateral for an account.
/// @dev A collaterals is a vault for which account's balances are under the control of the currently enabled
/// controller vault. Only the owner or an operator of the account can call this function. Unless it's a duplicate,
/// the collateral is added to the end of the array. There can be at most 10 unique collaterals enabled at a time.
/// Account status checks are performed.
/// @param account The account address for which the collateral is being enabled.
/// @param vault The address being enabled as a collateral.
function enableCollateral(address account, address vault) external payable;
/// @notice Disables a collateral for an account.
/// @dev This function does not preserve the order of collaterals in the array obtained using the getCollaterals
/// function; the order may change. A collateral is a vault for which account’s balances are under the control of
/// the currently enabled controller vault. Only the owner or an operator of the account can call this function.
/// Disabling a collateral might change the order of collaterals in the array obtained using getCollaterals
/// function. Account status checks are performed.
/// @param account The account address for which the collateral is being disabled.
/// @param vault The address of a collateral being disabled.
function disableCollateral(address account, address vault) external payable;
/// @notice Swaps the position of two collaterals so that they appear switched in the array of collaterals for a
/// given account obtained by calling getCollaterals function.
/// @dev A collateral is a vault for which account’s balances are under the control of the currently enabled
/// controller vault. Only the owner or an operator of the account can call this function. The order of collaterals
/// can be changed by specifying the indices of the two collaterals to be swapped. Indices are zero-based and must
/// be in the range of 0 to the number of collaterals minus 1. index1 must be lower than index2. Account status
/// checks are performed.
/// @param account The address of the account for which the collaterals are being reordered.
/// @param index1 The index of the first collateral to be swapped.
/// @param index2 The index of the second collateral to be swapped.
function reorderCollaterals(address account, uint8 index1, uint8 index2) external payable;
/// @notice Returns an array of enabled controllers for an account.
/// @dev A controller is a vault that has been chosen for an account to have special control over the account's
/// balances in enabled collaterals vaults. A user can have multiple controllers during a call execution, but at
/// most one can be selected when the account status check is performed.
/// @param account The address of the account whose controllers are being queried.
/// @return An array of addresses that are the enabled controllers for the account.
function getControllers(address account) external view returns (address[] memory);
/// @notice Returns whether a controller is enabled for an account.
/// @dev A controller is a vault that has been chosen for an account to have special control over account’s
/// balances in the enabled collaterals vaults.
/// @param account The address of the account that is being checked.
/// @param vault The address of the controller that is being checked.
/// @return A boolean value that indicates whether the vault is enabled controller for the account or not.
function isControllerEnabled(address account, address vault) external view returns (bool);
/// @notice Enables a controller for an account.
/// @dev A controller is a vault that has been chosen for an account to have special control over account’s
/// balances in the enabled collaterals vaults. Only the owner or an operator of the account can call this function.
/// Unless it's a duplicate, the controller is added to the end of the array. Transiently, there can be at most 10
/// unique controllers enabled at a time, but at most one can be enabled after the outermost checks-deferrable
/// call concludes. Account status checks are performed.
/// @param account The address for which the controller is being enabled.
/// @param vault The address of the controller being enabled.
function enableController(address account, address vault) external payable;
/// @notice Disables a controller for an account.
/// @dev A controller is a vault that has been chosen for an account to have special control over account’s
/// balances in the enabled collaterals vaults. Only the vault itself can call this function. Disabling a controller
/// might change the order of controllers in the array obtained using getControllers function. Account status checks
/// are performed.
/// @param account The address for which the calling controller is being disabled.
function disableController(address account) external payable;
/// @notice Executes signed arbitrary data by self-calling into the EVC.
/// @dev Low-level call function is used to execute the arbitrary data signed by the owner or the operator on the
/// EVC contract. During that call, EVC becomes msg.sender.
/// @param signer The address signing the permit message (ECDSA) or verifying the permit message signature
/// (ERC-1271). It's also the owner or the operator of all the accounts for which authentication will be needed
/// during the execution of the arbitrary data call.
/// @param sender The address of the msg.sender which is expected to execute the data signed by the signer. If
/// address(0) is passed, the msg.sender is ignored.
/// @param nonceNamespace The nonce namespace for which the nonce is being used.
/// @param nonce The nonce for the given account and nonce namespace. A valid nonce value is considered to be the
/// value currently stored and can take any value between 0 and type(uint256).max - 1.
/// @param deadline The timestamp after which the permit is considered expired.
/// @param value The amount of value to be forwarded with the call. If the value is type(uint256).max, the whole
/// balance of the EVC contract will be forwarded.
/// @param data The encoded data which is self-called on the EVC contract.
/// @param signature The signature of the data signed by the signer.
function permit(
address signer,
address sender,
uint256 nonceNamespace,
uint256 nonce,
uint256 deadline,
uint256 value,
bytes calldata data,
bytes calldata signature
) external payable;
/// @notice Calls into a target contract as per data encoded.
/// @dev This function defers the account and vault status checks (it's a checks-deferrable call). If the outermost
/// call ends, the account and vault status checks are performed.
/// @dev This function can be used to interact with any contract while checks are deferred. If the target contract
/// is msg.sender, msg.sender is called back with the calldata provided and the context set up according to the
/// account provided. If the target contract is not msg.sender, only the owner or the operator of the account
/// provided can call this function.
/// @dev This function can be used to recover the remaining value from the EVC contract.
/// @param targetContract The address of the contract to be called.
/// @param onBehalfOfAccount If the target contract is msg.sender, the address of the account which will be set
/// in the context. It assumes msg.sender has authenticated the account themselves. If the target contract is
/// not msg.sender, the address of the account for which it is checked whether msg.sender is authorized to act
/// on behalf of.
/// @param value The amount of value to be forwarded with the call. If the value is type(uint256).max, the whole
/// balance of the EVC contract will be forwarded.
/// @param data The encoded data which is called on the target contract.
/// @return result The result of the call.
function call(
address targetContract,
address onBehalfOfAccount,
uint256 value,
bytes calldata data
) external payable returns (bytes memory result);
/// @notice For a given account, calls into one of the enabled collateral vaults from the currently enabled
/// controller vault as per data encoded.
/// @dev This function defers the account and vault status checks (it's a checks-deferrable call). If the outermost
/// call ends, the account and vault status checks are performed.
/// @dev This function can be used to interact with any contract while checks are deferred as long as the contract
/// is enabled as a collateral of the account and the msg.sender is the only enabled controller of the account.
/// @param targetCollateral The collateral address to be called.
/// @param onBehalfOfAccount The address of the account for which it is checked whether msg.sender is authorized to
/// act on behalf.
/// @param value The amount of value to be forwarded with the call. If the value is type(uint256).max, the whole
/// balance of the EVC contract will be forwarded.
/// @param data The encoded data which is called on the target collateral.
/// @return result The result of the call.
function controlCollateral(
address targetCollateral,
address onBehalfOfAccount,
uint256 value,
bytes calldata data
) external payable returns (bytes memory result);
/// @notice Executes multiple calls into the target contracts while checks deferred as per batch items provided.
/// @dev This function defers the account and vault status checks (it's a checks-deferrable call). If the outermost
/// call ends, the account and vault status checks are performed.
/// @dev The authentication rules for each batch item are the same as for the call function.
/// @param items An array of batch items to be executed.
function batch(BatchItem[] calldata items) external payable;
/// @notice Executes multiple calls into the target contracts while checks deferred as per batch items provided.
/// @dev This function always reverts as it's only used for simulation purposes. This function cannot be called
/// within a checks-deferrable call.
/// @param items An array of batch items to be executed.
function batchRevert(BatchItem[] calldata items) external payable;
/// @notice Executes multiple calls into the target contracts while checks deferred as per batch items provided.
/// @dev This function does not modify state and should only be used for simulation purposes. This function cannot
/// be called within a checks-deferrable call.
/// @param items An array of batch items to be executed.
/// @return batchItemsResult An array of batch item results for each item.
/// @return accountsStatusCheckResult An array of account status check results for each account.
/// @return vaultsStatusCheckResult An array of vault status check results for each vault.
function batchSimulation(BatchItem[] calldata items)
external
payable
returns (
BatchItemResult[] memory batchItemsResult,
StatusCheckResult[] memory accountsStatusCheckResult,
StatusCheckResult[] memory vaultsStatusCheckResult
);
/// @notice Retrieves the timestamp of the last successful account status check performed for a specific account.
/// @dev This function reverts if the checks are in progress.
/// @dev The account status check is considered to be successful if it calls into the selected controller vault and
/// obtains expected magic value. This timestamp does not change if the account status is considered valid when no
/// controller enabled. When consuming, one might need to ensure that the account status check is not deferred at
/// the moment.
/// @param account The address of the account for which the last status check timestamp is being queried.
/// @return The timestamp of the last status check as a uint256.
function getLastAccountStatusCheckTimestamp(address account) external view returns (uint256);
/// @notice Checks whether the status check is deferred for a given account.
/// @dev This function reverts if the checks are in progress.
/// @param account The address of the account for which it is checked whether the status check is deferred.
/// @return A boolean flag that indicates whether the status check is deferred or not.
function isAccountStatusCheckDeferred(address account) external view returns (bool);
/// @notice Checks the status of an account and reverts if it is not valid.
/// @dev If checks deferred, the account is added to the set of accounts to be checked at the end of the outermost
/// checks-deferrable call. There can be at most 10 unique accounts added to the set at a time. Account status
/// check is performed by calling into the selected controller vault and passing the array of currently enabled
/// collaterals. If controller is not selected, the account is always considered valid.
/// @param account The address of the account to be checked.
function requireAccountStatusCheck(address account) external payable;
/// @notice Forgives previously deferred account status check.
/// @dev Account address is removed from the set of addresses for which status checks are deferred. This function
/// can only be called by the currently enabled controller of a given account. Depending on the vault
/// implementation, may be needed in the liquidation flow.
/// @param account The address of the account for which the status check is forgiven.
function forgiveAccountStatusCheck(address account) external payable;
/// @notice Checks whether the status check is deferred for a given vault.
/// @dev This function reverts if the checks are in progress.
/// @param vault The address of the vault for which it is checked whether the status check is deferred.
/// @return A boolean flag that indicates whether the status check is deferred or not.
function isVaultStatusCheckDeferred(address vault) external view returns (bool);
/// @notice Checks the status of a vault and reverts if it is not valid.
/// @dev If checks deferred, the vault is added to the set of vaults to be checked at the end of the outermost
/// checks-deferrable call. There can be at most 10 unique vaults added to the set at a time. This function can
/// only be called by the vault itself.
function requireVaultStatusCheck() external payable;
/// @notice Forgives previously deferred vault status check.
/// @dev Vault address is removed from the set of addresses for which status checks are deferred. This function can
/// only be called by the vault itself.
function forgiveVaultStatusCheck() external payable;
/// @notice Checks the status of an account and a vault and reverts if it is not valid.
/// @dev If checks deferred, the account and the vault are added to the respective sets of accounts and vaults to be
/// checked at the end of the outermost checks-deferrable call. Account status check is performed by calling into
/// selected controller vault and passing the array of currently enabled collaterals. If controller is not selected,
/// the account is always considered valid. This function can only be called by the vault itself.
/// @param account The address of the account to be checked.
function requireAccountAndVaultStatusCheck(address account) external payable;
}
// lib/euler-vault-kit/src/interfaces/IHookTarget.sol
/// @title IHookTarget
/// @author Euler Labs (https://www.eulerlabs.com/)
/// @custom:security-contact security@euler.xyz
/// @notice Provides an interface for the hook target contract
interface IHookTarget {
/// @notice If given contract is a hook target, it is expected to return the bytes4 magic value that is the selector
/// of this function
/// @return The bytes4 magic value (0x87439e04) that is the selector of this function
function isHookTarget() external view returns (bytes4);
}
// lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol)
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
* case an upgrade adds a module that needs to be initialized.
*
* For example:
*
* [.hljs-theme-light.nopadding]
* ```solidity
* contract MyToken is ERC20Upgradeable {
* function initialize() initializer public {
* __ERC20_init("MyToken", "MTK");
* }
* }
*
* contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
* function initializeV2() reinitializer(2) public {
* __ERC20Permit_init("MyToken");
* }
* }
* ```
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*
* [CAUTION]
* ====
* Avoid leaving a contract uninitialized.
*
* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
* contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
* the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() {
* _disableInitializers();
* }
* ```
* ====
*/
abstract contract Initializable {
/**
* @dev Storage of the initializable contract.
*
* It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions
* when using with upgradeable contracts.
*
* @custom:storage-location erc7201:openzeppelin.storage.Initializable
*/
struct InitializableStorage {
/**
* @dev Indicates that the contract has been initialized.
*/
uint64 _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool _initializing;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Initializable")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;
/**
* @dev The contract is already initialized.
*/
error InvalidInitialization();
/**
* @dev The contract is not initializing.
*/
error NotInitializing();
/**
* @dev Triggered when the contract has been initialized or reinitialized.
*/
event Initialized(uint64 version);
/**
* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
* `onlyInitializing` functions can be used to initialize parent contracts.
*
* Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any
* number of times. This behavior in the constructor can be useful during testing and is not expected to be used in
* production.
*
* Emits an {Initialized} event.
*/
modifier initializer() {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
// Cache values to avoid duplicated sloads
bool isTopLevelCall = !$._initializing;
uint64 initialized = $._initialized;
// Allowed calls:
// - initialSetup: the contract is not in the initializing state and no previous version was
// initialized
// - construction: the contract is initialized at version 1 (no reininitialization) and the
// current contract is just being deployed
bool initialSetup = initialized == 0 && isTopLevelCall;
bool construction = initialized == 1 && address(this).code.length == 0;
if (!initialSetup && !construction) {
revert InvalidInitialization();
}
$._initialized = 1;
if (isTopLevelCall) {
$._initializing = true;
}
_;
if (isTopLevelCall) {
$._initializing = false;
emit Initialized(1);
}
}
/**
* @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
* contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
* used to initialize parent contracts.
*
* A reinitializer may be used after the original initialization step. This is essential to configure modules that
* are added through upgrades and that require initialization.
*
* When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
* cannot be nested. If one is invoked in the context of another, execution will revert.
*
* Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
* a contract, executing them in the right order is up to the developer or operator.
*
* WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization.
*
* Emits an {Initialized} event.
*/
modifier reinitializer(uint64 version) {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing || $._initialized >= version) {
revert InvalidInitialization();
}
$._initialized = version;
$._initializing = true;
_;
$._initializing = false;
emit Initialized(version);
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} and {reinitializer} modifiers, directly or indirectly.
*/
modifier onlyInitializing() {
_checkInitializing();
_;
}
/**
* @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.
*/
function _checkInitializing() internal view virtual {
if (!_isInitializing()) {
revert NotInitializing();
}
}
/**
* @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
* Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
* to any version. It is recommended to use this to lock implementation contracts that are designed to be called
* through proxies.
*
* Emits an {Initialized} event the first time it is successfully executed.
*/
function _disableInitializers() internal virtual {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing) {
revert InvalidInitialization();
}
if ($._initialized != type(uint64).max) {
$._initialized = type(uint64).max;
emit Initialized(type(uint64).max);
}
}
/**
* @dev Returns the highest version that has been initialized. See {reinitializer}.
*/
function _getInitializedVersion() inSubmitted on: 2025-10-10 12:42:49
Comments
Log in to comment.
No comments yet.