Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Source Code Verified (Exact Match)
Contract Name:
StaderConfig
Compiler Version
v0.8.16+commit.07a7930e
Optimization Enabled:
Yes with 200 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity 0.8.16; import './library/UtilLib.sol'; import './interfaces/IStaderConfig.sol'; import '@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol'; contract StaderConfig is IStaderConfig, AccessControlUpgradeable { // staked ETH per node on beacon chain i.e. 32 ETH bytes32 public constant ETH_PER_NODE = keccak256('ETH_PER_NODE'); //amount of ETH for pre-deposit on beacon chain i.e 1 ETH bytes32 public constant PRE_DEPOSIT_SIZE = keccak256('PRE_DEPOSIT_SIZE'); //amount of ETH for full deposit on beacon chain i.e 31 ETH bytes32 public constant FULL_DEPOSIT_SIZE = keccak256('FULL_DEPOSIT_SIZE'); // ETH to WEI ratio i.e 1e18 bytes32 public constant DECIMALS = keccak256('DECIMALS'); //Total fee bips bytes32 public constant TOTAL_FEE = keccak256('TOTAL_FEE'); //maximum length of operator name string bytes32 public constant OPERATOR_MAX_NAME_LENGTH = keccak256('OPERATOR_MAX_NAME_LENGTH'); bytes32 public constant SOCIALIZING_POOL_CYCLE_DURATION = keccak256('SOCIALIZING_POOL_CYCLE_DURATION'); bytes32 public constant SOCIALIZING_POOL_OPT_IN_COOLING_PERIOD = keccak256('SOCIALIZING_POOL_OPT_IN_COOLING_PERIOD'); bytes32 public constant REWARD_THRESHOLD = keccak256('REWARD_THRESHOLD'); bytes32 public constant MIN_DEPOSIT_AMOUNT = keccak256('MIN_DEPOSIT_AMOUNT'); bytes32 public constant MAX_DEPOSIT_AMOUNT = keccak256('MAX_DEPOSIT_AMOUNT'); bytes32 public constant MIN_WITHDRAW_AMOUNT = keccak256('MIN_WITHDRAW_AMOUNT'); bytes32 public constant MAX_WITHDRAW_AMOUNT = keccak256('MAX_WITHDRAW_AMOUNT'); //minimum delay between user requesting withdraw and request finalization bytes32 public constant MIN_BLOCK_DELAY_TO_FINALIZE_WITHDRAW_REQUEST = keccak256('MIN_BLOCK_DELAY_TO_FINALIZE_WITHDRAW_REQUEST'); bytes32 public constant WITHDRAWN_KEYS_BATCH_SIZE = keccak256('WITHDRAWN_KEYS_BATCH_SIZE'); bytes32 public constant ADMIN = keccak256('ADMIN'); bytes32 public constant STADER_TREASURY = keccak256('STADER_TREASURY'); bytes32 public constant override POOL_UTILS = keccak256('POOL_UTILS'); bytes32 public constant override POOL_SELECTOR = keccak256('POOL_SELECTOR'); bytes32 public constant override SD_COLLATERAL = keccak256('SD_COLLATERAL'); bytes32 public constant override OPERATOR_REWARD_COLLECTOR = keccak256('OPERATOR_REWARD_COLLECTOR'); bytes32 public constant override VAULT_FACTORY = keccak256('VAULT_FACTORY'); bytes32 public constant override STADER_ORACLE = keccak256('STADER_ORACLE'); bytes32 public constant override AUCTION_CONTRACT = keccak256('AuctionContract'); bytes32 public constant override PENALTY_CONTRACT = keccak256('PENALTY_CONTRACT'); bytes32 public constant override PERMISSIONED_POOL = keccak256('PERMISSIONED_POOL'); bytes32 public constant override STAKE_POOL_MANAGER = keccak256('STAKE_POOL_MANAGER'); bytes32 public constant override ETH_DEPOSIT_CONTRACT = keccak256('ETH_DEPOSIT_CONTRACT'); bytes32 public constant override PERMISSIONLESS_POOL = keccak256('PERMISSIONLESS_POOL'); bytes32 public constant override USER_WITHDRAW_MANAGER = keccak256('USER_WITHDRAW_MANAGER'); bytes32 public constant override STADER_INSURANCE_FUND = keccak256('STADER_INSURANCE_FUND'); bytes32 public constant override PERMISSIONED_NODE_REGISTRY = keccak256('PERMISSIONED_NODE_REGISTRY'); bytes32 public constant override PERMISSIONLESS_NODE_REGISTRY = keccak256('PERMISSIONLESS_NODE_REGISTRY'); bytes32 public constant override PERMISSIONED_SOCIALIZING_POOL = keccak256('PERMISSIONED_SOCIALIZING_POOL'); bytes32 public constant override PERMISSIONLESS_SOCIALIZING_POOL = keccak256('PERMISSIONLESS_SOCIALIZING_POOL'); bytes32 public constant override NODE_EL_REWARD_VAULT_IMPLEMENTATION = keccak256('NODE_EL_REWARD_VAULT_IMPLEMENTATION'); bytes32 public constant override VALIDATOR_WITHDRAWAL_VAULT_IMPLEMENTATION = keccak256('VALIDATOR_WITHDRAWAL_VAULT_IMPLEMENTATION'); //POR Feed Proxy bytes32 public constant override ETH_BALANCE_POR_FEED = keccak256('ETH_BALANCE_POR_FEED'); bytes32 public constant override ETHX_SUPPLY_POR_FEED = keccak256('ETHX_SUPPLY_POR_FEED'); //Roles bytes32 public constant override MANAGER = keccak256('MANAGER'); bytes32 public constant override OPERATOR = keccak256('OPERATOR'); bytes32 public constant SD = keccak256('SD'); bytes32 public constant ETHx = keccak256('ETHx'); mapping(bytes32 => uint256) private constantsMap; mapping(bytes32 => uint256) private variablesMap; mapping(bytes32 => address) private accountsMap; mapping(bytes32 => address) private contractsMap; mapping(bytes32 => address) private tokensMap; /// @custom:oz-upgrades-unsafe-allow constructor constructor() { _disableInitializers(); } function initialize(address _admin, address _ethDepositContract) external initializer { UtilLib.checkNonZeroAddress(_admin); UtilLib.checkNonZeroAddress(_ethDepositContract); __AccessControl_init(); setConstant(ETH_PER_NODE, 32 ether); setConstant(PRE_DEPOSIT_SIZE, 1 ether); setConstant(FULL_DEPOSIT_SIZE, 31 ether); setConstant(TOTAL_FEE, 10000); setConstant(DECIMALS, 1e18); setConstant(OPERATOR_MAX_NAME_LENGTH, 255); setVariable(MIN_DEPOSIT_AMOUNT, 1e14); setVariable(MAX_DEPOSIT_AMOUNT, 10000 ether); setVariable(MIN_WITHDRAW_AMOUNT, 1e14); setVariable(MAX_WITHDRAW_AMOUNT, 10000 ether); setVariable(WITHDRAWN_KEYS_BATCH_SIZE, 50); setVariable(MIN_BLOCK_DELAY_TO_FINALIZE_WITHDRAW_REQUEST, 600); setContract(ETH_DEPOSIT_CONTRACT, _ethDepositContract); _grantRole(DEFAULT_ADMIN_ROLE, _admin); } //Variables Setters function updateSocializingPoolCycleDuration(uint256 _socializingPoolCycleDuration) external onlyRole(MANAGER) { setVariable(SOCIALIZING_POOL_CYCLE_DURATION, _socializingPoolCycleDuration); } function updateSocializingPoolOptInCoolingPeriod(uint256 _SocializePoolOptInCoolingPeriod) external onlyRole(MANAGER) { setVariable(SOCIALIZING_POOL_OPT_IN_COOLING_PERIOD, _SocializePoolOptInCoolingPeriod); } function updateRewardsThreshold(uint256 _rewardsThreshold) external onlyRole(MANAGER) { setVariable(REWARD_THRESHOLD, _rewardsThreshold); } /** * @dev update the minimum deposit amount * @param _minDepositAmount minimum deposit amount */ function updateMinDepositAmount(uint256 _minDepositAmount) external onlyRole(MANAGER) { setVariable(MIN_DEPOSIT_AMOUNT, _minDepositAmount); verifyDepositAndWithdrawLimits(); } /** * @dev update the maximum deposit amount * @param _maxDepositAmount maximum deposit amount */ function updateMaxDepositAmount(uint256 _maxDepositAmount) external onlyRole(MANAGER) { setVariable(MAX_DEPOSIT_AMOUNT, _maxDepositAmount); verifyDepositAndWithdrawLimits(); } /** * @dev update the minimum withdraw amount * @param _minWithdrawAmount minimum withdraw amount */ function updateMinWithdrawAmount(uint256 _minWithdrawAmount) external onlyRole(DEFAULT_ADMIN_ROLE) { setVariable(MIN_WITHDRAW_AMOUNT, _minWithdrawAmount); verifyDepositAndWithdrawLimits(); } /** * @dev update the maximum withdraw amount * @param _maxWithdrawAmount maximum withdraw amount */ function updateMaxWithdrawAmount(uint256 _maxWithdrawAmount) external onlyRole(DEFAULT_ADMIN_ROLE) { setVariable(MAX_WITHDRAW_AMOUNT, _maxWithdrawAmount); verifyDepositAndWithdrawLimits(); } function updateMinBlockDelayToFinalizeWithdrawRequest(uint256 _minBlockDelay) external onlyRole(DEFAULT_ADMIN_ROLE) { setVariable(MIN_BLOCK_DELAY_TO_FINALIZE_WITHDRAW_REQUEST, _minBlockDelay); } /** * @notice update the max number of withdrawn validator keys reported by oracle in single tx * @dev only `OPERATOR` can call * @param _withdrawnKeysBatchSize updated maximum withdrawn key limit in the oracle input */ function updateWithdrawnKeysBatchSize(uint256 _withdrawnKeysBatchSize) external onlyRole(OPERATOR) { setVariable(WITHDRAWN_KEYS_BATCH_SIZE, _withdrawnKeysBatchSize); } //Accounts Setters function updateAdmin(address _admin) external onlyRole(DEFAULT_ADMIN_ROLE) { address oldAdmin = accountsMap[ADMIN]; _grantRole(DEFAULT_ADMIN_ROLE, _admin); setAccount(ADMIN, _admin); _revokeRole(DEFAULT_ADMIN_ROLE, oldAdmin); } function updateStaderTreasury(address _staderTreasury) external onlyRole(MANAGER) { setAccount(STADER_TREASURY, _staderTreasury); } // Contracts Setters function updatePoolUtils(address _poolUtils) external onlyRole(DEFAULT_ADMIN_ROLE) { setContract(POOL_UTILS, _poolUtils); } function updatePoolSelector(address _poolSelector) external onlyRole(DEFAULT_ADMIN_ROLE) { setContract(POOL_SELECTOR, _poolSelector); } function updateSDCollateral(address _sdCollateral) external onlyRole(DEFAULT_ADMIN_ROLE) { setContract(SD_COLLATERAL, _sdCollateral); } function updateOperatorRewardsCollector(address _operatorRewardsCollector) external onlyRole(DEFAULT_ADMIN_ROLE) { setContract(OPERATOR_REWARD_COLLECTOR, _operatorRewardsCollector); } function updateVaultFactory(address _vaultFactory) external onlyRole(DEFAULT_ADMIN_ROLE) { setContract(VAULT_FACTORY, _vaultFactory); } function updateAuctionContract(address _auctionContract) external onlyRole(DEFAULT_ADMIN_ROLE) { setContract(AUCTION_CONTRACT, _auctionContract); } function updateStaderOracle(address _staderOracle) external onlyRole(DEFAULT_ADMIN_ROLE) { setContract(STADER_ORACLE, _staderOracle); } function updatePenaltyContract(address _penaltyContract) external onlyRole(DEFAULT_ADMIN_ROLE) { setContract(PENALTY_CONTRACT, _penaltyContract); } function updatePermissionedPool(address _permissionedPool) external onlyRole(DEFAULT_ADMIN_ROLE) { setContract(PERMISSIONED_POOL, _permissionedPool); } function updateStakePoolManager(address _stakePoolManager) external onlyRole(DEFAULT_ADMIN_ROLE) { setContract(STAKE_POOL_MANAGER, _stakePoolManager); } function updatePermissionlessPool(address _permissionlessPool) external onlyRole(DEFAULT_ADMIN_ROLE) { setContract(PERMISSIONLESS_POOL, _permissionlessPool); } function updateUserWithdrawManager(address _userWithdrawManager) external onlyRole(DEFAULT_ADMIN_ROLE) { setContract(USER_WITHDRAW_MANAGER, _userWithdrawManager); } function updateStaderInsuranceFund(address _staderInsuranceFund) external onlyRole(DEFAULT_ADMIN_ROLE) { setContract(STADER_INSURANCE_FUND, _staderInsuranceFund); } function updatePermissionedNodeRegistry(address _permissionedNodeRegistry) external onlyRole(DEFAULT_ADMIN_ROLE) { setContract(PERMISSIONED_NODE_REGISTRY, _permissionedNodeRegistry); } function updatePermissionlessNodeRegistry(address _permissionlessNodeRegistry) external onlyRole(DEFAULT_ADMIN_ROLE) { setContract(PERMISSIONLESS_NODE_REGISTRY, _permissionlessNodeRegistry); } function updatePermissionedSocializingPool(address _permissionedSocializePool) external onlyRole(DEFAULT_ADMIN_ROLE) { setContract(PERMISSIONED_SOCIALIZING_POOL, _permissionedSocializePool); } function updatePermissionlessSocializingPool(address _permissionlessSocializePool) external onlyRole(DEFAULT_ADMIN_ROLE) { setContract(PERMISSIONLESS_SOCIALIZING_POOL, _permissionlessSocializePool); } function updateNodeELRewardImplementation(address _nodeELRewardVaultImpl) external onlyRole(DEFAULT_ADMIN_ROLE) { setContract(NODE_EL_REWARD_VAULT_IMPLEMENTATION, _nodeELRewardVaultImpl); } function updateValidatorWithdrawalVaultImplementation(address _validatorWithdrawalVaultImpl) external onlyRole(DEFAULT_ADMIN_ROLE) { setContract(VALIDATOR_WITHDRAWAL_VAULT_IMPLEMENTATION, _validatorWithdrawalVaultImpl); } function updateETHBalancePORFeedProxy(address _ethBalanceProxy) external onlyRole(DEFAULT_ADMIN_ROLE) { setContract(ETH_BALANCE_POR_FEED, _ethBalanceProxy); } function updateETHXSupplyPORFeedProxy(address _ethXSupplyProxy) external onlyRole(DEFAULT_ADMIN_ROLE) { setContract(ETHX_SUPPLY_POR_FEED, _ethXSupplyProxy); } function updateStaderToken(address _staderToken) external onlyRole(DEFAULT_ADMIN_ROLE) { setToken(SD, _staderToken); } function updateETHxToken(address _ethX) external onlyRole(DEFAULT_ADMIN_ROLE) { setToken(ETHx, _ethX); } //Constants Getters function getStakedEthPerNode() external view override returns (uint256) { return constantsMap[ETH_PER_NODE]; } function getPreDepositSize() external view override returns (uint256) { return constantsMap[PRE_DEPOSIT_SIZE]; } function getFullDepositSize() external view override returns (uint256) { return constantsMap[FULL_DEPOSIT_SIZE]; } function getDecimals() external view override returns (uint256) { return constantsMap[DECIMALS]; } function getTotalFee() external view override returns (uint256) { return constantsMap[TOTAL_FEE]; } function getOperatorMaxNameLength() external view override returns (uint256) { return constantsMap[OPERATOR_MAX_NAME_LENGTH]; } //Variables Getters function getSocializingPoolCycleDuration() external view override returns (uint256) { return variablesMap[SOCIALIZING_POOL_CYCLE_DURATION]; } function getSocializingPoolOptInCoolingPeriod() external view override returns (uint256) { return variablesMap[SOCIALIZING_POOL_OPT_IN_COOLING_PERIOD]; } function getRewardsThreshold() external view override returns (uint256) { return variablesMap[REWARD_THRESHOLD]; } function getMinDepositAmount() external view override returns (uint256) { return variablesMap[MIN_DEPOSIT_AMOUNT]; } function getMaxDepositAmount() external view override returns (uint256) { return variablesMap[MAX_DEPOSIT_AMOUNT]; } function getMinWithdrawAmount() external view override returns (uint256) { return variablesMap[MIN_WITHDRAW_AMOUNT]; } function getMaxWithdrawAmount() external view override returns (uint256) { return variablesMap[MAX_WITHDRAW_AMOUNT]; } function getMinBlockDelayToFinalizeWithdrawRequest() external view override returns (uint256) { return variablesMap[MIN_BLOCK_DELAY_TO_FINALIZE_WITHDRAW_REQUEST]; } function getWithdrawnKeyBatchSize() external view override returns (uint256) { return variablesMap[WITHDRAWN_KEYS_BATCH_SIZE]; } //Account Getters function getAdmin() external view returns (address) { return accountsMap[ADMIN]; } function getStaderTreasury() external view override returns (address) { return accountsMap[STADER_TREASURY]; } //Contracts Getters function getPoolUtils() external view override returns (address) { return contractsMap[POOL_UTILS]; } function getPoolSelector() external view override returns (address) { return contractsMap[POOL_SELECTOR]; } function getSDCollateral() external view override returns (address) { return contractsMap[SD_COLLATERAL]; } function getOperatorRewardsCollector() external view override returns (address) { return contractsMap[OPERATOR_REWARD_COLLECTOR]; } function getVaultFactory() external view override returns (address) { return contractsMap[VAULT_FACTORY]; } function getStaderOracle() external view override returns (address) { return contractsMap[STADER_ORACLE]; } function getAuctionContract() external view override returns (address) { return contractsMap[AUCTION_CONTRACT]; } function getPenaltyContract() external view override returns (address) { return contractsMap[PENALTY_CONTRACT]; } function getPermissionedPool() external view override returns (address) { return contractsMap[PERMISSIONED_POOL]; } function getStakePoolManager() external view override returns (address) { return contractsMap[STAKE_POOL_MANAGER]; } function getETHDepositContract() external view override returns (address) { return contractsMap[ETH_DEPOSIT_CONTRACT]; } function getPermissionlessPool() external view override returns (address) { return contractsMap[PERMISSIONLESS_POOL]; } function getUserWithdrawManager() external view override returns (address) { return contractsMap[USER_WITHDRAW_MANAGER]; } function getStaderInsuranceFund() external view override returns (address) { return contractsMap[STADER_INSURANCE_FUND]; } function getPermissionedNodeRegistry() external view override returns (address) { return contractsMap[PERMISSIONED_NODE_REGISTRY]; } function getPermissionlessNodeRegistry() external view override returns (address) { return contractsMap[PERMISSIONLESS_NODE_REGISTRY]; } function getPermissionedSocializingPool() external view override returns (address) { return contractsMap[PERMISSIONED_SOCIALIZING_POOL]; } function getPermissionlessSocializingPool() external view override returns (address) { return contractsMap[PERMISSIONLESS_SOCIALIZING_POOL]; } function getNodeELRewardVaultImplementation() external view override returns (address) { return contractsMap[NODE_EL_REWARD_VAULT_IMPLEMENTATION]; } function getValidatorWithdrawalVaultImplementation() external view override returns (address) { return contractsMap[VALIDATOR_WITHDRAWAL_VAULT_IMPLEMENTATION]; } //POR Feed Proxy Getters function getETHBalancePORFeedProxy() external view override returns (address) { return contractsMap[ETH_BALANCE_POR_FEED]; } function getETHXSupplyPORFeedProxy() external view override returns (address) { return contractsMap[ETHX_SUPPLY_POR_FEED]; } //Token Getters function getStaderToken() external view override returns (address) { return tokensMap[SD]; } function getETHxToken() external view returns (address) { return tokensMap[ETHx]; } // SETTER HELPERS function setConstant(bytes32 key, uint256 val) internal { constantsMap[key] = val; emit SetConstant(key, val); } function setVariable(bytes32 key, uint256 val) internal { variablesMap[key] = val; emit SetConstant(key, val); } function setAccount(bytes32 key, address val) internal { UtilLib.checkNonZeroAddress(val); accountsMap[key] = val; emit SetAccount(key, val); } function setContract(bytes32 key, address val) internal { UtilLib.checkNonZeroAddress(val); contractsMap[key] = val; emit SetContract(key, val); } function setToken(bytes32 key, address val) internal { UtilLib.checkNonZeroAddress(val); tokensMap[key] = val; emit SetToken(key, val); } //only stader protocol contract check function onlyStaderContract(address _addr, bytes32 _contractName) external view returns (bool) { return (_addr == contractsMap[_contractName]); } function onlyManagerRole(address account) external view override returns (bool) { return hasRole(MANAGER, account); } function onlyOperatorRole(address account) external view override returns (bool) { return hasRole(OPERATOR, account); } function verifyDepositAndWithdrawLimits() internal view { if ( !(variablesMap[MIN_DEPOSIT_AMOUNT] != 0 && variablesMap[MIN_WITHDRAW_AMOUNT] != 0 && variablesMap[MIN_DEPOSIT_AMOUNT] <= variablesMap[MAX_DEPOSIT_AMOUNT] && variablesMap[MIN_WITHDRAW_AMOUNT] <= variablesMap[MAX_WITHDRAW_AMOUNT] && variablesMap[MIN_WITHDRAW_AMOUNT] <= variablesMap[MIN_DEPOSIT_AMOUNT] && variablesMap[MAX_WITHDRAW_AMOUNT] >= variablesMap[MAX_DEPOSIT_AMOUNT]) ) { revert InvalidLimits(); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (access/AccessControl.sol) pragma solidity ^0.8.0; import "./IAccessControlUpgradeable.sol"; import "../utils/ContextUpgradeable.sol"; import "../utils/StringsUpgradeable.sol"; import "../utils/introspection/ERC165Upgradeable.sol"; import "../proxy/utils/Initializable.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 AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable { function __AccessControl_init() internal onlyInitializing { } function __AccessControl_init_unchained() internal onlyInitializing { } 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(IAccessControlUpgradeable).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 ", StringsUpgradeable.toHexString(account), " is missing role ", StringsUpgradeable.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()); } } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[49] private __gap; }
// 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 IAccessControlUpgradeable { /** * @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) (proxy/utils/Initializable.sol) pragma solidity ^0.8.2; import "../../utils/AddressUpgradeable.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 Indicates that the contract has been initialized. * @custom:oz-retyped-from bool */ uint8 private _initialized; /** * @dev Indicates that the contract is in the process of being initialized. */ bool private _initializing; /** * @dev Triggered when the contract has been initialized or reinitialized. */ event Initialized(uint8 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 functions marked with `initializer` can be nested in the context of a * constructor. * * Emits an {Initialized} event. */ modifier initializer() { bool isTopLevelCall = !_initializing; require( (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1), "Initializable: contract is already initialized" ); _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 255 will prevent any future reinitialization. * * Emits an {Initialized} event. */ modifier reinitializer(uint8 version) { require(!_initializing && _initialized < version, "Initializable: contract is already initialized"); _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() { require(_initializing, "Initializable: contract is not initializing"); _; } /** * @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 { require(!_initializing, "Initializable: contract is initializing"); if (_initialized != type(uint8).max) { _initialized = type(uint8).max; emit Initialized(type(uint8).max); } } /** * @dev Returns the highest version that has been initialized. See {reinitializer}. */ function _getInitializedVersion() internal view returns (uint8) { return _initialized; } /** * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}. */ function _isInitializing() internal view returns (bool) { return _initializing; } }
// 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 AddressUpgradeable { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * * 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 v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; import "../proxy/utils/Initializable.sol"; /** * @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 ContextUpgradeable is Initializable { function __Context_init() internal onlyInitializing { } function __Context_init_unchained() internal onlyInitializing { } function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[50] private __gap; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) pragma solidity ^0.8.0; import "./IERC165Upgradeable.sol"; import "../../proxy/utils/Initializable.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 ERC165Upgradeable is Initializable, IERC165Upgradeable { function __ERC165_init() internal onlyInitializing { } function __ERC165_init_unchained() internal onlyInitializing { } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165Upgradeable).interfaceId; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[50] private __gap; }
// 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 IERC165Upgradeable { /** * @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); }
// 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 MathUpgradeable { 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 SignedMathUpgradeable { /** * @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 (last updated v4.9.0) (utils/Strings.sol) pragma solidity ^0.8.0; import "./math/MathUpgradeable.sol"; import "./math/SignedMathUpgradeable.sol"; /** * @dev String operations. */ library StringsUpgradeable { 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 = MathUpgradeable.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(SignedMathUpgradeable.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, MathUpgradeable.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: GPL-3.0-or-later pragma solidity 0.8.16; import '../library/ValidatorStatus.sol'; struct Validator { ValidatorStatus status; // status of validator bytes pubkey; //pubkey of the validator bytes preDepositSignature; //signature for 1 ETH deposit on beacon chain bytes depositSignature; //signature for 31 ETH deposit on beacon chain address withdrawVaultAddress; //withdrawal vault address of validator uint256 operatorId; // stader network assigned Id uint256 depositBlock; // block number of the 31ETH deposit uint256 withdrawnBlock; //block number when oracle report validator as withdrawn } struct Operator { bool active; // operator status bool optedForSocializingPool; // operator opted for socializing pool string operatorName; // name of the operator address payable operatorRewardAddress; //Eth1 address of node for reward address operatorAddress; //address of operator to interact with stader } // Interface for the NodeRegistry contract interface INodeRegistry { // Errors error DuplicatePoolIDOrPoolNotAdded(); error OperatorAlreadyOnBoardedInProtocol(); error maxKeyLimitReached(); error OperatorNotOnBoarded(); error InvalidKeyCount(); error InvalidStartAndEndIndex(); error OperatorIsDeactivate(); error MisMatchingInputKeysSize(); error PageNumberIsZero(); error UNEXPECTED_STATUS(); error PubkeyAlreadyExist(); error NotEnoughSDCollateral(); error TooManyVerifiedKeysReported(); error TooManyWithdrawnKeysReported(); // Events event AddedValidatorKey(address indexed nodeOperator, bytes pubkey, uint256 validatorId); event ValidatorMarkedAsFrontRunned(bytes pubkey, uint256 validatorId); event ValidatorWithdrawn(bytes pubkey, uint256 validatorId); event ValidatorStatusMarkedAsInvalidSignature(bytes pubkey, uint256 validatorId); event UpdatedValidatorDepositBlock(uint256 validatorId, uint256 depositBlock); event UpdatedMaxNonTerminalKeyPerOperator(uint64 maxNonTerminalKeyPerOperator); event UpdatedInputKeyCountLimit(uint256 batchKeyDepositLimit); event UpdatedStaderConfig(address staderConfig); event UpdatedOperatorDetails(address indexed nodeOperator, string operatorName, address rewardAddress); event IncreasedTotalActiveValidatorCount(uint256 totalActiveValidatorCount); event UpdatedVerifiedKeyBatchSize(uint256 verifiedKeysBatchSize); event UpdatedWithdrawnKeyBatchSize(uint256 withdrawnKeysBatchSize); event DecreasedTotalActiveValidatorCount(uint256 totalActiveValidatorCount); function withdrawnValidators(bytes[] calldata _pubkeys) external; function markValidatorReadyToDeposit( bytes[] calldata _readyToDepositPubkey, bytes[] calldata _frontRunPubkey, bytes[] calldata _invalidSignaturePubkey ) external; // return validator struct for a validator Id function validatorRegistry(uint256) external view returns ( ValidatorStatus status, bytes calldata pubkey, bytes calldata preDepositSignature, bytes calldata depositSignature, address withdrawVaultAddress, uint256 operatorId, uint256 depositTime, uint256 withdrawnTime ); // returns the operator struct given operator Id function operatorStructById(uint256) external view returns ( bool active, bool optedForSocializingPool, string calldata operatorName, address payable operatorRewardAddress, address operatorAddress ); // Returns the last block the operator changed the opt-in status for socializing pool function getSocializingPoolStateChangeBlock(uint256 _operatorId) external view returns (uint256); function getAllActiveValidators(uint256 _pageNumber, uint256 _pageSize) external view returns (Validator[] memory); function getValidatorsByOperator( address _operator, uint256 _pageNumber, uint256 _pageSize ) external view returns (Validator[] memory); /** * * @param _nodeOperator @notice operator total non withdrawn keys within a specified validator list * @param _startIndex start index in validator queue to start with * @param _endIndex up to end index of validator queue to to count */ function getOperatorTotalNonTerminalKeys( address _nodeOperator, uint256 _startIndex, uint256 _endIndex ) external view returns (uint64); // returns the total number of queued validators across all operators function getTotalQueuedValidatorCount() external view returns (uint256); // returns the total number of active validators across all operators function getTotalActiveValidatorCount() external view returns (uint256); function getCollateralETH() external view returns (uint256); function getOperatorTotalKeys(uint256 _operatorId) external view returns (uint256 totalKeys); function operatorIDByAddress(address) external view returns (uint256); function getOperatorRewardAddress(uint256 _operatorId) external view returns (address payable); function isExistingPubkey(bytes calldata _pubkey) external view returns (bool); function isExistingOperator(address _operAddr) external view returns (bool); function POOL_ID() external view returns (uint8); function inputKeyCountLimit() external view returns (uint16); function nextOperatorId() external view returns (uint256); function nextValidatorId() external view returns (uint256); function maxNonTerminalKeyPerOperator() external view returns (uint64); function verifiedKeyBatchSize() external view returns (uint256); function totalActiveValidatorCount() external view returns (uint256); function validatorIdByPubkey(bytes calldata _pubkey) external view returns (uint256); function validatorIdsByOperatorId(uint256, uint256) external view returns (uint256); }
// SPDX-License-Identifier: GPL-3.0-or-later pragma solidity 0.8.16; import './INodeRegistry.sol'; // Interface for the PoolUtils contract interface IPoolUtils { // Errors error EmptyNameString(); error PoolIdNotPresent(); error PubkeyDoesNotExit(); error PubkeyAlreadyExist(); error NameCrossedMaxLength(); error InvalidLengthOfPubkey(); error OperatorIsNotOnboarded(); error InvalidLengthOfSignature(); error ExistingOrMismatchingPoolId(); // Events event PoolAdded(uint8 indexed poolId, address poolAddress); event PoolAddressUpdated(uint8 indexed poolId, address poolAddress); event DeactivatedPool(uint8 indexed poolId, address poolAddress); event UpdatedStaderConfig(address staderConfig); event ExitValidator(bytes pubkey); // returns the details of a specific pool function poolAddressById(uint8) external view returns (address poolAddress); function poolIdArray(uint256) external view returns (uint8); function getPoolIdArray() external view returns (uint8[] memory); // Pool functions function addNewPool(uint8 _poolId, address _poolAddress) external; function updatePoolAddress(uint8 _poolId, address _poolAddress) external; function processValidatorExitList(bytes[] calldata _pubkeys) external; function getOperatorTotalNonTerminalKeys( uint8 _poolId, address _nodeOperator, uint256 _startIndex, uint256 _endIndex ) external view returns (uint256); function getSocializingPoolAddress(uint8 _poolId) external view returns (address); // Pool getters function getProtocolFee(uint8 _poolId) external view returns (uint256); // returns the protocol fee (0-10000) function getOperatorFee(uint8 _poolId) external view returns (uint256); // returns the operator fee (0-10000) function getTotalActiveValidatorCount() external view returns (uint256); //returns total active validators across all pools function getActiveValidatorCountByPool(uint8 _poolId) external view returns (uint256); // returns the total number of active validators in a specific pool function getQueuedValidatorCountByPool(uint8 _poolId) external view returns (uint256); // returns the total number of queued validators in a specific pool function getCollateralETH(uint8 _poolId) external view returns (uint256); function getNodeRegistry(uint8 _poolId) external view returns (address); // check for duplicate pubkey across all pools function isExistingPubkey(bytes calldata _pubkey) external view returns (bool); // check for duplicate operator across all pools function isExistingOperator(address _operAddr) external view returns (bool); function isExistingPoolId(uint8 _poolId) external view returns (bool); function getOperatorPoolId(address _operAddr) external view returns (uint8); function getValidatorPoolId(bytes calldata _pubkey) external view returns (uint8); function onlyValidName(string calldata _name) external; function onlyValidKeys( bytes calldata _pubkey, bytes calldata _preDepositSignature, bytes calldata _depositSignature ) external; function calculateRewardShare(uint8 _poolId, uint256 _totalRewards) external view returns ( uint256 userShare, uint256 operatorShare, uint256 protocolShare ); }
// SPDX-License-Identifier: MIT pragma solidity 0.8.16; interface IStaderConfig { // Errors error InvalidLimits(); error InvalidMinDepositValue(); error InvalidMaxDepositValue(); error InvalidMinWithdrawValue(); error InvalidMaxWithdrawValue(); // Events event SetConstant(bytes32 key, uint256 amount); event SetVariable(bytes32 key, uint256 amount); event SetAccount(bytes32 key, address newAddress); event SetContract(bytes32 key, address newAddress); event SetToken(bytes32 key, address newAddress); //Contracts function POOL_UTILS() external view returns (bytes32); function POOL_SELECTOR() external view returns (bytes32); function SD_COLLATERAL() external view returns (bytes32); function OPERATOR_REWARD_COLLECTOR() external view returns (bytes32); function VAULT_FACTORY() external view returns (bytes32); function STADER_ORACLE() external view returns (bytes32); function AUCTION_CONTRACT() external view returns (bytes32); function PENALTY_CONTRACT() external view returns (bytes32); function PERMISSIONED_POOL() external view returns (bytes32); function STAKE_POOL_MANAGER() external view returns (bytes32); function ETH_DEPOSIT_CONTRACT() external view returns (bytes32); function PERMISSIONLESS_POOL() external view returns (bytes32); function USER_WITHDRAW_MANAGER() external view returns (bytes32); function STADER_INSURANCE_FUND() external view returns (bytes32); function PERMISSIONED_NODE_REGISTRY() external view returns (bytes32); function PERMISSIONLESS_NODE_REGISTRY() external view returns (bytes32); function PERMISSIONED_SOCIALIZING_POOL() external view returns (bytes32); function PERMISSIONLESS_SOCIALIZING_POOL() external view returns (bytes32); function NODE_EL_REWARD_VAULT_IMPLEMENTATION() external view returns (bytes32); function VALIDATOR_WITHDRAWAL_VAULT_IMPLEMENTATION() external view returns (bytes32); //POR Feed Proxy function ETH_BALANCE_POR_FEED() external view returns (bytes32); function ETHX_SUPPLY_POR_FEED() external view returns (bytes32); //Roles function MANAGER() external view returns (bytes32); function OPERATOR() external view returns (bytes32); // Constants function getStakedEthPerNode() external view returns (uint256); function getPreDepositSize() external view returns (uint256); function getFullDepositSize() external view returns (uint256); function getDecimals() external view returns (uint256); function getTotalFee() external view returns (uint256); function getOperatorMaxNameLength() external view returns (uint256); // Variables function getSocializingPoolCycleDuration() external view returns (uint256); function getSocializingPoolOptInCoolingPeriod() external view returns (uint256); function getRewardsThreshold() external view returns (uint256); function getMinDepositAmount() external view returns (uint256); function getMaxDepositAmount() external view returns (uint256); function getMinWithdrawAmount() external view returns (uint256); function getMaxWithdrawAmount() external view returns (uint256); function getMinBlockDelayToFinalizeWithdrawRequest() external view returns (uint256); function getWithdrawnKeyBatchSize() external view returns (uint256); // Accounts function getAdmin() external view returns (address); function getStaderTreasury() external view returns (address); // Contracts function getPoolUtils() external view returns (address); function getPoolSelector() external view returns (address); function getSDCollateral() external view returns (address); function getOperatorRewardsCollector() external view returns (address); function getVaultFactory() external view returns (address); function getStaderOracle() external view returns (address); function getAuctionContract() external view returns (address); function getPenaltyContract() external view returns (address); function getPermissionedPool() external view returns (address); function getStakePoolManager() external view returns (address); function getETHDepositContract() external view returns (address); function getPermissionlessPool() external view returns (address); function getUserWithdrawManager() external view returns (address); function getStaderInsuranceFund() external view returns (address); function getPermissionedNodeRegistry() external view returns (address); function getPermissionlessNodeRegistry() external view returns (address); function getPermissionedSocializingPool() external view returns (address); function getPermissionlessSocializingPool() external view returns (address); function getNodeELRewardVaultImplementation() external view returns (address); function getValidatorWithdrawalVaultImplementation() external view returns (address); function getETHBalancePORFeedProxy() external view returns (address); function getETHXSupplyPORFeedProxy() external view returns (address); // Tokens function getStaderToken() external view returns (address); function getETHxToken() external view returns (address); //checks roles and stader contracts function onlyStaderContract(address _addr, bytes32 _contractName) external view returns (bool); function onlyManagerRole(address account) external view returns (bool); function onlyOperatorRole(address account) external view returns (bool); }
// SPDX-License-Identifier: MIT pragma solidity 0.8.16; import './IStaderConfig.sol'; interface IVaultProxy { error CallerNotOwner(); error AlreadyInitialized(); event UpdatedOwner(address owner); event UpdatedStaderConfig(address staderConfig); //Getters function vaultSettleStatus() external view returns (bool); function isValidatorWithdrawalVault() external view returns (bool); function isInitialized() external view returns (bool); function poolId() external view returns (uint8); function id() external view returns (uint256); function owner() external view returns (address); function staderConfig() external view returns (IStaderConfig); //Setters function updateOwner() external; function updateStaderConfig(address _staderConfig) external; }
// SPDX-License-Identifier: MIT pragma solidity 0.8.16; import '../interfaces/IStaderConfig.sol'; import '../interfaces/INodeRegistry.sol'; import '../interfaces/IPoolUtils.sol'; import '../interfaces/IVaultProxy.sol'; library UtilLib { error ZeroAddress(); error InvalidPubkeyLength(); error CallerNotManager(); error CallerNotOperator(); error CallerNotStaderContract(); error CallerNotWithdrawVault(); error TransferFailed(); uint64 private constant VALIDATOR_PUBKEY_LENGTH = 48; /// @notice zero address check modifier function checkNonZeroAddress(address _address) internal pure { if (_address == address(0)) revert ZeroAddress(); } //checks for Manager role in staderConfig function onlyManagerRole(address _addr, IStaderConfig _staderConfig) internal view { if (!_staderConfig.onlyManagerRole(_addr)) { revert CallerNotManager(); } } function onlyOperatorRole(address _addr, IStaderConfig _staderConfig) internal view { if (!_staderConfig.onlyOperatorRole(_addr)) { revert CallerNotOperator(); } } //checks if caller is a stader contract address function onlyStaderContract( address _addr, IStaderConfig _staderConfig, bytes32 _contractName ) internal view { if (!_staderConfig.onlyStaderContract(_addr, _contractName)) { revert CallerNotStaderContract(); } } function getPubkeyForValidSender( uint8 _poolId, uint256 _validatorId, address _addr, IStaderConfig _staderConfig ) internal view returns (bytes memory) { address nodeRegistry = IPoolUtils(_staderConfig.getPoolUtils()).getNodeRegistry(_poolId); (, bytes memory pubkey, , , address withdrawVaultAddress, , , ) = INodeRegistry(nodeRegistry).validatorRegistry( _validatorId ); if (_addr != withdrawVaultAddress) { revert CallerNotWithdrawVault(); } return pubkey; } function getOperatorForValidSender( uint8 _poolId, uint256 _validatorId, address _addr, IStaderConfig _staderConfig ) internal view returns (address) { address nodeRegistry = IPoolUtils(_staderConfig.getPoolUtils()).getNodeRegistry(_poolId); (, , , , address withdrawVaultAddress, uint256 operatorId, , ) = INodeRegistry(nodeRegistry).validatorRegistry( _validatorId ); if (_addr != withdrawVaultAddress) { revert CallerNotWithdrawVault(); } (, , , , address operator) = INodeRegistry(nodeRegistry).operatorStructById(operatorId); return operator; } function onlyValidatorWithdrawVault( uint8 _poolId, uint256 _validatorId, address _addr, IStaderConfig _staderConfig ) internal view { address nodeRegistry = IPoolUtils(_staderConfig.getPoolUtils()).getNodeRegistry(_poolId); (, , , , address withdrawVaultAddress, , , ) = INodeRegistry(nodeRegistry).validatorRegistry(_validatorId); if (_addr != withdrawVaultAddress) { revert CallerNotWithdrawVault(); } } function getOperatorAddressByValidatorId( uint8 _poolId, uint256 _validatorId, IStaderConfig _staderConfig ) internal view returns (address) { address nodeRegistry = IPoolUtils(_staderConfig.getPoolUtils()).getNodeRegistry(_poolId); (, , , , , uint256 operatorId, , ) = INodeRegistry(nodeRegistry).validatorRegistry(_validatorId); (, , , , address operatorAddress) = INodeRegistry(nodeRegistry).operatorStructById(operatorId); return operatorAddress; } function getOperatorAddressByOperatorId( uint8 _poolId, uint256 _operatorId, IStaderConfig _staderConfig ) internal view returns (address) { address nodeRegistry = IPoolUtils(_staderConfig.getPoolUtils()).getNodeRegistry(_poolId); (, , , , address operatorAddress) = INodeRegistry(nodeRegistry).operatorStructById(_operatorId); return operatorAddress; } function getOperatorRewardAddress(address _operator, IStaderConfig _staderConfig) internal view returns (address payable) { uint8 poolId = IPoolUtils(_staderConfig.getPoolUtils()).getOperatorPoolId(_operator); address nodeRegistry = IPoolUtils(_staderConfig.getPoolUtils()).getNodeRegistry(poolId); uint256 operatorId = INodeRegistry(nodeRegistry).operatorIDByAddress(_operator); return INodeRegistry(nodeRegistry).getOperatorRewardAddress(operatorId); } /** * @notice Computes the public key root. * @param _pubkey The validator public key for which to compute the root. * @return The root of the public key. */ function getPubkeyRoot(bytes calldata _pubkey) internal pure returns (bytes32) { if (_pubkey.length != VALIDATOR_PUBKEY_LENGTH) { revert InvalidPubkeyLength(); } // Append 16 bytes of zero padding to the pubkey and compute its hash to get the pubkey root. return sha256(abi.encodePacked(_pubkey, bytes16(0))); } function getValidatorSettleStatus(bytes calldata _pubkey, IStaderConfig _staderConfig) internal view returns (bool) { uint8 poolId = IPoolUtils(_staderConfig.getPoolUtils()).getValidatorPoolId(_pubkey); address nodeRegistry = IPoolUtils(_staderConfig.getPoolUtils()).getNodeRegistry(poolId); uint256 validatorId = INodeRegistry(nodeRegistry).validatorIdByPubkey(_pubkey); (, , , , address withdrawVaultAddress, , , ) = INodeRegistry(nodeRegistry).validatorRegistry(validatorId); return IVaultProxy(withdrawVaultAddress).vaultSettleStatus(); } function computeExchangeRate( uint256 totalETHBalance, uint256 totalETHXSupply, IStaderConfig _staderConfig ) internal view returns (uint256) { uint256 DECIMALS = _staderConfig.getDecimals(); uint256 newExchangeRate = (totalETHBalance == 0 || totalETHXSupply == 0) ? DECIMALS : (totalETHBalance * DECIMALS) / totalETHXSupply; return newExchangeRate; } function sendValue(address _receiver, uint256 _amount) internal { (bool success, ) = payable(_receiver).call{value: _amount}(''); if (!success) { revert TransferFailed(); } } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.16; enum ValidatorStatus { INITIALIZED, INVALID_SIGNATURE, FRONT_RUN, PRE_DEPOSIT, DEPOSITED, WITHDRAWN }
{ "optimizer": { "enabled": true, "runs": 200 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "remappings": [], "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"InvalidLimits","type":"error"},{"inputs":[],"name":"InvalidMaxDepositValue","type":"error"},{"inputs":[],"name":"InvalidMaxWithdrawValue","type":"error"},{"inputs":[],"name":"InvalidMinDepositValue","type":"error"},{"inputs":[],"name":"InvalidMinWithdrawValue","type":"error"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","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":false,"internalType":"bytes32","name":"key","type":"bytes32"},{"indexed":false,"internalType":"address","name":"newAddress","type":"address"}],"name":"SetAccount","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"key","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"SetConstant","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"key","type":"bytes32"},{"indexed":false,"internalType":"address","name":"newAddress","type":"address"}],"name":"SetContract","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"key","type":"bytes32"},{"indexed":false,"internalType":"address","name":"newAddress","type":"address"}],"name":"SetToken","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"key","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"SetVariable","type":"event"},{"inputs":[],"name":"ADMIN","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"AUCTION_CONTRACT","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DECIMALS","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ETHX_SUPPLY_POR_FEED","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ETH_BALANCE_POR_FEED","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ETH_DEPOSIT_CONTRACT","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ETH_PER_NODE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ETHx","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FULL_DEPOSIT_SIZE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MANAGER","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_DEPOSIT_AMOUNT","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_WITHDRAW_AMOUNT","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MIN_BLOCK_DELAY_TO_FINALIZE_WITHDRAW_REQUEST","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MIN_DEPOSIT_AMOUNT","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MIN_WITHDRAW_AMOUNT","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"NODE_EL_REWARD_VAULT_IMPLEMENTATION","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"OPERATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"OPERATOR_MAX_NAME_LENGTH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"OPERATOR_REWARD_COLLECTOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PENALTY_CONTRACT","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERMISSIONED_NODE_REGISTRY","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERMISSIONED_POOL","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERMISSIONED_SOCIALIZING_POOL","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERMISSIONLESS_NODE_REGISTRY","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERMISSIONLESS_POOL","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERMISSIONLESS_SOCIALIZING_POOL","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"POOL_SELECTOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"POOL_UTILS","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PRE_DEPOSIT_SIZE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"REWARD_THRESHOLD","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SD","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SD_COLLATERAL","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SOCIALIZING_POOL_CYCLE_DURATION","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SOCIALIZING_POOL_OPT_IN_COOLING_PERIOD","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"STADER_INSURANCE_FUND","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"STADER_ORACLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"STADER_TREASURY","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"STAKE_POOL_MANAGER","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOTAL_FEE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"USER_WITHDRAW_MANAGER","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VALIDATOR_WITHDRAWAL_VAULT_IMPLEMENTATION","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VAULT_FACTORY","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WITHDRAWN_KEYS_BATCH_SIZE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAdmin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAuctionContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDecimals","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getETHBalancePORFeedProxy","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getETHDepositContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getETHXSupplyPORFeedProxy","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getETHxToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getFullDepositSize","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMaxDepositAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMaxWithdrawAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMinBlockDelayToFinalizeWithdrawRequest","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMinDepositAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMinWithdrawAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getNodeELRewardVaultImplementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getOperatorMaxNameLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getOperatorRewardsCollector","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPenaltyContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPermissionedNodeRegistry","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPermissionedPool","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPermissionedSocializingPool","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPermissionlessNodeRegistry","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPermissionlessPool","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPermissionlessSocializingPool","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPoolSelector","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPoolUtils","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPreDepositSize","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getRewardsThreshold","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSDCollateral","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSocializingPoolCycleDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSocializingPoolOptInCoolingPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getStaderInsuranceFund","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getStaderOracle","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getStaderToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getStaderTreasury","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getStakePoolManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getStakedEthPerNode","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getUserWithdrawManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getValidatorWithdrawalVaultImplementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getVaultFactory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getWithdrawnKeyBatchSize","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":"address","name":"_admin","type":"address"},{"internalType":"address","name":"_ethDepositContract","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"onlyManagerRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"onlyOperatorRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"},{"internalType":"bytes32","name":"_contractName","type":"bytes32"}],"name":"onlyStaderContract","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","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":"address","name":"_admin","type":"address"}],"name":"updateAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_auctionContract","type":"address"}],"name":"updateAuctionContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_ethBalanceProxy","type":"address"}],"name":"updateETHBalancePORFeedProxy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_ethXSupplyProxy","type":"address"}],"name":"updateETHXSupplyPORFeedProxy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_ethX","type":"address"}],"name":"updateETHxToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxDepositAmount","type":"uint256"}],"name":"updateMaxDepositAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxWithdrawAmount","type":"uint256"}],"name":"updateMaxWithdrawAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_minBlockDelay","type":"uint256"}],"name":"updateMinBlockDelayToFinalizeWithdrawRequest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_minDepositAmount","type":"uint256"}],"name":"updateMinDepositAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_minWithdrawAmount","type":"uint256"}],"name":"updateMinWithdrawAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_nodeELRewardVaultImpl","type":"address"}],"name":"updateNodeELRewardImplementation","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_operatorRewardsCollector","type":"address"}],"name":"updateOperatorRewardsCollector","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_penaltyContract","type":"address"}],"name":"updatePenaltyContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_permissionedNodeRegistry","type":"address"}],"name":"updatePermissionedNodeRegistry","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_permissionedPool","type":"address"}],"name":"updatePermissionedPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_permissionedSocializePool","type":"address"}],"name":"updatePermissionedSocializingPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_permissionlessNodeRegistry","type":"address"}],"name":"updatePermissionlessNodeRegistry","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_permissionlessPool","type":"address"}],"name":"updatePermissionlessPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_permissionlessSocializePool","type":"address"}],"name":"updatePermissionlessSocializingPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_poolSelector","type":"address"}],"name":"updatePoolSelector","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_poolUtils","type":"address"}],"name":"updatePoolUtils","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rewardsThreshold","type":"uint256"}],"name":"updateRewardsThreshold","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_sdCollateral","type":"address"}],"name":"updateSDCollateral","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_socializingPoolCycleDuration","type":"uint256"}],"name":"updateSocializingPoolCycleDuration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_SocializePoolOptInCoolingPeriod","type":"uint256"}],"name":"updateSocializingPoolOptInCoolingPeriod","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_staderInsuranceFund","type":"address"}],"name":"updateStaderInsuranceFund","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_staderOracle","type":"address"}],"name":"updateStaderOracle","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_staderToken","type":"address"}],"name":"updateStaderToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_staderTreasury","type":"address"}],"name":"updateStaderTreasury","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_stakePoolManager","type":"address"}],"name":"updateStakePoolManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_userWithdrawManager","type":"address"}],"name":"updateUserWithdrawManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_validatorWithdrawalVaultImpl","type":"address"}],"name":"updateValidatorWithdrawalVaultImplementation","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_vaultFactory","type":"address"}],"name":"updateVaultFactory","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_withdrawnKeysBatchSize","type":"uint256"}],"name":"updateWithdrawnKeysBatchSize","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
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.