Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: GPL-3.0-or-later
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;

    bytes32 public constant override SD_UTILITY_POOL = keccak256('SD_UTILITY_POOL');
    bytes32 public constant override SD_INCENTIVE_CONTROLLER = keccak256('SD_INCENTIVE_CONTROLLER');

    /// @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);
    }

    function updateSDUtilityPool(address _utilityPool) external onlyRole(DEFAULT_ADMIN_ROLE) {
        setContract(SD_UTILITY_POOL, _utilityPool);
    }

    function updateSDIncentiveController(address _sdIncentiveController) external onlyRole(DEFAULT_ADMIN_ROLE) {
        setContract(SD_INCENTIVE_CONTROLLER, _sdIncentiveController);
    }

    //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];
    }

    function getSDUtilityPool() external view override returns (address) {
        return contractsMap[SD_UTILITY_POOL];
    }

    function getSDIncentiveController() external view override returns (address) {
        return contractsMap[SD_INCENTIVE_CONTROLLER];
    }

    //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 {
        if (constantsMap[key] == val) {
            revert IndenticalValue();
        }
        constantsMap[key] = val;
        emit SetConstant(key, val);
    }

    function setVariable(bytes32 key, uint256 val) internal {
        if (variablesMap[key] == val) {
            revert IndenticalValue();
        }
        variablesMap[key] = val;
        emit SetConstant(key, val);
    }

    function setAccount(bytes32 key, address val) internal {
        UtilLib.checkNonZeroAddress(val);
        if (accountsMap[key] == val) {
            revert IndenticalValue();
        }
        accountsMap[key] = val;
        emit SetAccount(key, val);
    }

    function setContract(bytes32 key, address val) internal {
        UtilLib.checkNonZeroAddress(val);
        if (contractsMap[key] == val) {
            revert IndenticalValue();
        }
        contractsMap[key] = val;
        emit SetContract(key, val);
    }

    function setToken(bytes32 key, address val) internal {
        UtilLib.checkNonZeroAddress(val);
        if (tokensMap[key] == val) {
            revert IndenticalValue();
        }
        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: GPL-3.0-or-later
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: GPL-3.0-or-later
pragma solidity 0.8.16;

interface IStaderConfig {
    // Errors
    error InvalidLimits();
    error InvalidMinDepositValue();
    error InvalidMaxDepositValue();
    error InvalidMinWithdrawValue();
    error InvalidMaxWithdrawValue();
    error IndenticalValue();

    // 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);

    //SD Utility Pool

    function SD_UTILITY_POOL() external view returns (bytes32);

    function SD_INCENTIVE_CONTROLLER() 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);

    function getSDUtilityPool() external view returns (address);

    function getSDIncentiveController() 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
// OpenZeppelin Contracts (last updated v4.8.0-rc.1) (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:
 *
 * ```
 * 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}:
 *
 * ```
 * 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.
 */
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: 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();
    error CallerNotExistingRewardAddress();
    error CallerNotNewRewardAddress();

    // 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 RewardAddressProposed(address indexed nodeOperator, address indexed rewardAddress);
    event OperatorRewardAddressUpdated(address indexed nodeOperator, address indexed rewardAddress);
    event UpdatedOperatorName(address indexed nodeOperator, string operatorName);
    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 MismatchingPoolId();
    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);
    event ExitOperator(address indexed operator, uint256 totalAmount);

    // 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 processOperatorExit(address _operator, uint256 totalAmount) 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: GPL-3.0-or-later
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
// 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 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 (last updated v4.8.0-rc.1) (utils/Strings.sol)

pragma solidity ^0.8.0;

import "./math/MathUpgradeable.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 `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);
    }
}

// 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 (last updated v4.8.0-rc.1) (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]
 * ```
 * 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 Internal function that returns the initialized version. Returns `_initialized`
     */
    function _getInitializedVersion() internal view returns (uint8) {
        return _initialized;
    }

    /**
     * @dev Internal function that returns the initialized version. Returns `_initializing`
     */
    function _isInitializing() internal view returns (bool) {
        return _initializing;
    }
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.16;

enum ValidatorStatus {
    INITIALIZED,
    INVALID_SIGNATURE,
    FRONT_RUN,
    PRE_DEPOSIT,
    DEPOSITED,
    WITHDRAWN
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0-rc.1) (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) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 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 10, 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 * 8) < value ? 1 : 0);
        }
    }
}

// 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.8.0-rc.1) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library AddressUpgradeable {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return 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 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);
        }
    }
}

{
  "remappings": [
    "@chainlink/=node_modules/@chainlink/",
    "@eth-optimism/=node_modules/@eth-optimism/",
    "@openzeppelin/=node_modules/@openzeppelin/",
    "@uniswap/=node_modules/@uniswap/",
    "base64-sol/=node_modules/base64-sol/",
    "ds-test/=lib/forge-std/lib/ds-test/src/",
    "eth-gas-reporter/=node_modules/eth-gas-reporter/",
    "forge-std/=lib/forge-std/src/",
    "hardhat/=node_modules/hardhat/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 10000
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs"
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "london",
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"IndenticalValue","type":"error"},{"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":"SD_INCENTIVE_CONTROLLER","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SD_UTILITY_POOL","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":"getSDIncentiveController","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSDUtilityPool","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":"address","name":"_sdIncentiveController","type":"address"}],"name":"updateSDIncentiveController","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_utilityPool","type":"address"}],"name":"updateSDUtilityPool","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"}]

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

0x608060405234801561001057600080fd5b506004361061084d5760003560e01c80636d28ad1c1161044b578063b11c699d11610240578063defd024d11610140578063f0141d84116100d3578063f6c278c1116100a2578063fa71fcbb11610087578063fa71fcbb146120e0578063ff387f3a14612130578063ff4f35461461218057600080fd5b8063f6c278c1146120a6578063f83c7787146120cd57600080fd5b8063f0141d8414611fcc578063f122961f1461201c578063f4914d3314612043578063f63718e71461209357600080fd5b8063e7bdba321161010f578063e7bdba3214611e9a578063e8fe187314611ec1578063ecf170a814611f1a578063f005691814611f7357600080fd5b8063defd024d14611dc2578063e069f71414611e1b578063e2f273bd14611e74578063e4f59b6c14611e8757600080fd5b8063bedcb34c116101d3578063ca78360c116101a2578063d2cee8ba11610187578063d2cee8ba14611d38578063d547741f14611d88578063dde63e8f14611d9b57600080fd5b8063ca78360c14611ccc578063cc45dabe14611cdf57600080fd5b8063bedcb34c14611c44578063c20573c114611c6b578063c58b4a9214611c7e578063c60470d314611ca557600080fd5b8063b5cfee6c1161020f578063b5cfee6c14611b9e578063b685784414611bf7578063b9894a1114611c1e578063bbb99bb514611c3157600080fd5b8063b11c699d14611ae6578063b312392214611b0d578063b479a51714611b3b578063b549dbff14611b8b57600080fd5b806388993d8b1161034b5780639ca76b73116102de578063a53bddd6116102ad578063a9fe1b3311610292578063a9fe1b3314611a21578063aa2f56c714611a7a578063aa95379514611a8d57600080fd5b8063a53bddd6146119d3578063a7919400146119fa57600080fd5b80639ca76b73146118c0578063a0b4079f14611919578063a217fddf14611972578063a469e2471461197a57600080fd5b806391d148541161031a57806391d148541461183a578063983d27371461187357806398c359271461189a5780639c34e411146118ad57600080fd5b806388993d8b1461174e5780638910115c146117755780638a4cfb58146117ce5780638f8b3867146117e157600080fd5b8063792c8cc3116103de5780637b5c8e60116103ad578063841b83b311610392578063841b83b3146116ed578063847802051461171457806385e2fcd31461172757600080fd5b80637b5c8e60146116c757806383148593146116da57600080fd5b8063792c8cc3146116165780637a87fa0b1461163d5780637ae316d0146116645780637b4cd7ec146116b457600080fd5b8063723b732c1161041a578063723b732c1461155c57806372ce78b01461156f57806377e8a0c3146115c857806379175a74146115ef57600080fd5b80636d28ad1c146114475780636e0fddfc146114a05780636e9960c3146114f057806372195b3e1461154957600080fd5b8063326a16a31161066157806352112bd3116105615780635be6ce69116104f457806363db7eae116104c3578063686a8b67116104a8578063686a8b67146113b45780636870bb2b146113db5780636ccb9d70146113ee57600080fd5b806363db7eae1461136657806367dcf1341461138d57600080fd5b80635be6ce69146112c05780635edc686e146112d35780636176bbde1461132c5780636240fb9c1461135357600080fd5b80635726a356116105305780635726a35614611237578063572c686a146112875780635b5961fc1461129a5780635b9cc8b1146112ad57600080fd5b806352112bd31461117d57806353f5713b146111a45780635455e472146111b75780635458a106146111de57600080fd5b80633871d0f1116105f45780634191e0fe116105c3578063485cc955116105a8578063485cc955146110ea578063489ed651146110fd5780634c34a9821461115657600080fd5b80634191e0fe1461109c57806344ba0ea2146110c357600080fd5b80633871d0f1146110285780633b6bcca01461104f5780633c128dad14611076578063403efe7f1461108957600080fd5b806336854d631161063057806336854d6314610f6e578063368f9d1714610f9557806336c157f414610fa8578063384002a21461100157600080fd5b8063326a16a314610ea057806334d17d7414610ef0578063360374a414610f0357806336568abe14610f5b57600080fd5b806318bcb2841161076c578063248a9ca3116106ff5780632a9cc2c4116106ce5780632e0f2625116106b35780632e0f262514610e0d5780632ec5e01814610e345780632f2ff15d14610e8d57600080fd5b80632a9cc2c414610d8d5780632ca03f6614610db457600080fd5b8063248a9ca314610cd75780632651644c14610cfa578063278671bb14610d0d5780632a0acc6a14610d6657600080fd5b80631c55cccd1161073b5780631c55cccd14610c265780631ca197a514610c4d5780631de03db814610c9d5780631ea30fef14610cb057600080fd5b806318bcb28414610b585780631af0fff314610bb15780631b2df85014610bd85780631bf6a41c14610bff57600080fd5b8063103f2907116107e4578063121669f1116107b3578063121669f114610a7f57806314e1b8fd14610a92578063152a91da14610ae257806318829fc314610b0857600080fd5b8063103f2907146109ce5780631049e32e146109f557806310deba2b14610a085780631202007514610a5857600080fd5b8063088ee72d11610820578063088ee72d146109145780630945d42c146109275780630a3fbd9a1461093a5780630bdf3166146109a757600080fd5b806301ffc9a7146108525780630430246e1461087a578063047cb439146108af57806308297645146108c4575b600080fd5b610865610860366004613c25565b612193565b60405190151581526020015b60405180910390f35b6108a17f9b1ae66636378b5626322a52e22518dd40bb04881cf0440ed16a20c0f902b24281565b604051908152602001610871565b6108c26108bd366004613c83565b61222c565b005b7f9b1ae66636378b5626322a52e22518dd40bb04881cf0440ed16a20c0f902b24260005260976020527f2b5f44404b80fc874d00ce3803444dc1d8415bef002ea5e3d4c6a1fc229b361b546108a1565b6108c2610922366004613c83565b612265565b6108c2610935366004613c9e565b61229a565b7fc5b1a6a0b843563e6a17ca90bc59d2315c523be427d0c9c2ba08d77ced4f46b1600052609a6020527f93bda0178f178a956e1154aad6f6d04aca130dc29bb626bd6774e853c8c9f354546001600160a01b03165b6040516001600160a01b039091168152602001610871565b6108a17f3e4ded42f360c2e6b1251d584085ae1d9aa9cbed18687fac6b6aef8eed1c5ad381565b6108a17f8d4341681b282735dd0d55670ff8e0ad68a80cbfc2cee847065e9f771470f88f81565b6108c2610a03366004613c83565b6122f6565b7f59b5f464ec5829246a81f005456c8cb714ee224aea800742e2dae497263e466960005260976020527ff1d631be95f382e871541957d68e9595b265874c488308836f37d0f22a9fbae9546108a1565b6108a17f4c9466ca1bf288a7334a7494f09a0acc38ee31628eaf8c68b574b9f0ec22a9c181565b6108c2610a8d366004613c83565b61232b565b7fb18278bb399a7088b8b0b26f4896d5ebaba4497c611bbe9d43abe92d9a1fe83d60005260986020527f8f1b9b075a455aa4e85ab4edea73c8fe6d4e2e5e4c6675d6135fefdca5e95a25546108a1565b6108a17e665c1b06e0667c56a1ca1706b7573435d1b9162c6327b5d0ea1daeb491ad0d81565b7f46b41285bb7b8513ce3a9d95cdf6916699fb00b47326e8d3850be1b6186e034960005260986020527f4d508419d31c3547aff85909df3c1fcaa249c360d3c9fa4e4f9e9c899cebbedc546108a1565b7f8d4341681b282735dd0d55670ff8e0ad68a80cbfc2cee847065e9f771470f88f600052609a6020527f510a692d092451633b86b6d5ebd49dd58b5ea01b6d0783a379a8169a08baac9f546001600160a01b031661098f565b6108a17fe5240448c78dfcff5bda4e4eed69ba9635df15d79da0e8a4cf889217106fa45b81565b6108a17faf290d8680820aad922855f39b306097b20e28774d6c1ad35a20325630c3a02c81565b6108a17f29384ec8473b541e7a7850226a4d1906a700f14cc394266ee08800ba62dc3af981565b6108a17fbd34382cd421c5250595893a4ed6cdb2125e6be7d5e0a9dbc469de5d583adfcf81565b7f3c6dcff840f36f9818a73b67d9d00197362f63687bd52e3c277bd0ffb30dde3360005260986020527f9e4fbca7af476428837bb1c0659b29a978bd5be1038b9848cfd6837f97c0c036546108a1565b6108c2610cab366004613c83565b612360565b6108a17ffa5a84fed05ba4c93fcc5ba1f4ad010e3bef3e6394b367aa10b3ec01997375cc81565b6108a1610ce5366004613c9e565b60009081526065602052604090206001015490565b6108c2610d08366004613c83565b612395565b7f5be667ef1f4c6c279e2aa7e62595a1045043db6a43145cb438c6d36e7a3c3ed8600052609a6020527f3f1c1b82007b7a87a83473281505b32822fde2464206a16635328330125264a8546001600160a01b031661098f565b6108a17fdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec4281565b6108a17fb134afa3abad633a84ab2d33dd5171f2b371e38b0f7bca001383aaf08ed6d2d181565b7fb134afa3abad633a84ab2d33dd5171f2b371e38b0f7bca001383aaf08ed6d2d1600052609a6020527fb5c61d48a513a298b438559aede2612ccf11b8fe4c725b0f159efab727297353546001600160a01b031661098f565b6108a17f08593985ae1bebfb02f6c30105edffb176a6d87c9fad54c434bf9b58f67e81b681565b7f3d88d1233771c5c30791fb6805b7f91424dae1e5a68a57da846ca7ff83c64029600052609a6020527f018f2aef664aeeb1561d5a44d318b67f16f75b697bf95eeabc62c48d36323e72546001600160a01b031661098f565b6108c2610e9b366004613cb7565b6123ca565b7f1c2fe98ddbbbffbcf7735c7446ffcddb5ccd2a4ec2ace0f7d90f73e9ff13fcc760005260986020527fd179a4a9329ee39fba707fd91c699ec0f088afc56731eb89ff424b873ac70844546108a1565b6108c2610efe366004613c83565b6123f4565b7e665c1b06e0667c56a1ca1706b7573435d1b9162c6327b5d0ea1daeb491ad0d600052609a6020527fe107fed811895732bef768006b62e8ce98d10a188d78cab697a91a201b5e2404546001600160a01b031661098f565b6108c2610f69366004613cb7565b612429565b6108a17ff935b8bf66b325637ad32ca875b588849cf4026791b79b4dc20623cd3dd36e2081565b6108c2610fa3366004613c83565b6124d0565b7f8e96355022bb9b9f4d9d4e01fe2b58f45e78549c982c401c96f75f33c5de457e600052609a6020527fe74d6d5cda9d4a34ee9d4950f99c58c26803c1cf17dbd9d3e9f82fcea7feb01e546001600160a01b031661098f565b6108a17f95bf18d68834a11aaae7b73ff6037326f163a81a7b5ea80cba96856ce2284fbd81565b6108a17f9f919a2294d86593fbcec81ea71aa683cec51c78771c642f8894ba8f3949705281565b6108a17fc5b1a6a0b843563e6a17ca90bc59d2315c523be427d0c9c2ba08d77ced4f46b181565b6108c2611084366004613c83565b612505565b6108c2611097366004613c83565b61253a565b6108a17fa4083e7a78dd898def03c51ce199cb4286b8828be4f6f46e04aec6176196747181565b6108a17f1c2fe98ddbbbffbcf7735c7446ffcddb5ccd2a4ec2ace0f7d90f73e9ff13fcc781565b6108c26110f8366004613ce3565b61256f565b7f690795c57e13eaf2526f76202b6799e9afdb069afca1e572f693953d013569d8600052609a6020527f38e84315fdfc8f1b16767d9fd043998a9ff60cfbcb629d8f48542b4e3ee87096546001600160a01b031661098f565b6108a17f712c13b90acf399d7bc7625370ce37c64b5eba41011b0961a88c2ef1648870cf81565b6108a17f602490b12960e59ddb584affd1da6cd5692f4455c1ba0cc4e865af81e111ebe281565b6108656111b2366004613c83565b612989565b6108a17f59b5f464ec5829246a81f005456c8cb714ee224aea800742e2dae497263e466981565b7fdb5d1c2a9350ca010dcdf3953da11a9e8f7c5e2918cdfa65500e84e7fd4fde7d600052609a6020527f642611b82cedca4c0a5510e3234bea9632cc7eb6e135d12e2ef4f8c68dc23add546001600160a01b031661098f565b7f712c13b90acf399d7bc7625370ce37c64b5eba41011b0961a88c2ef1648870cf60005260986020527ffcacc1044a5a1b4eb9c058396306426a857813d37a4fb6ccf5a3adde30e0c914546108a1565b6108c2611295366004613c9e565b6129c9565b6108c26112a8366004613c83565b612a1d565b6108c26112bb366004613c9e565b612a52565b6108c26112ce366004613c83565b612a87565b7fa4083e7a78dd898def03c51ce199cb4286b8828be4f6f46e04aec61761967471600052609a6020527f863e03b3878962463f3668c14c10a4aeeabb7baa9c7a9b990796f179109d8692546001600160a01b031661098f565b6108a17f2cf2377da51daa9c0d7e3f98c7532a67ee5e9398afad7b7db6e578b978a2709481565b610865611361366004613c83565b612abc565b6108a17f33271b56873d8abb908de4853f90a8a0ef8829548ec0bf6c298feed3917c50a281565b6108a17ff822b1f0c3b886ce1cdf1c2a5317844145470db33b02c63cae4813f8c9b2dc1781565b6108a17fc54a7590fe6738d7a81f393c1cf5ab3e577c91781037d93a5a9f5ce44f19eb5181565b6108c26113e9366004613c9e565b612afc565b7fd7e49a298cb2719de62e5df1024257eed316db6337361b3a30d56a7532404607600052609a6020527f294ce448c5d68d362948bb2b78c5571986464589b6911cc804ca52d7abbad2e3546001600160a01b031661098f565b7fbd34382cd421c5250595893a4ed6cdb2125e6be7d5e0a9dbc469de5d583adfcf600052609a6020527f3195564ffd56571794a8c7ffc14e3d393758b399f23318e874273db13addfdfe546001600160a01b031661098f565b7fc54a7590fe6738d7a81f393c1cf5ab3e577c91781037d93a5a9f5ce44f19eb5160005260986020527f4d985796191711ecc0d75f056488220f1f755856cdfe3ebd45de3537c37b9b50546108a1565b7fdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec4260005260996020527f15be86566e203c1f41b9ae149d9fbb01b2c14f503704423d739a6e3d2db5a9ee546001600160a01b031661098f565b6108c2611557366004613c83565b612b50565b6108c261156a366004613c9e565b612b85565b7f8567f5af844d68168987760a7ce1762804b9de703165fc50ce4fa85246016c9160005260996020527f2c1f6cfa08e101d854b66353df53d6eb32e981bfc1a8351f458fd54b64cfc181546001600160a01b031661098f565b6108a17f84b42b3d5e6851893d4418c6ebc9a4727e78afdf84e73674c8b9c1c2b1904e2d81565b6108a17f5be667ef1f4c6c279e2aa7e62595a1045043db6a43145cb438c6d36e7a3c3ed881565b6108a17f876943525608da6d95be5925fe6c4fe80e8622c8a76e7414f80e8ba210e0711c81565b6108a17f76d62e541b8d573110ca3eb9003e96426f530422a76712d1356f6c6ce50541ca81565b7f33271b56873d8abb908de4853f90a8a0ef8829548ec0bf6c298feed3917c50a260005260976020527f799f922a2554690a852ce3427a174a9d0f64f94f53730bd0c6e1e1fdc54799ae546108a1565b6108c26116c2366004613c83565b612bba565b6108c26116d5366004613c83565b612c0e565b6108c26116e8366004613c83565b612c43565b6108a17f8567f5af844d68168987760a7ce1762804b9de703165fc50ce4fa85246016c9181565b6108c2611722366004613c9e565b612c78565b6108a17fd7e49a298cb2719de62e5df1024257eed316db6337361b3a30d56a753240460781565b6108a17f6f8d0b773ad4970d3e7d47623dc9ce06a1b4fe833bf451d06a47e774f9acaa6381565b7f29384ec8473b541e7a7850226a4d1906a700f14cc394266ee08800ba62dc3af9600052609a6020527f249a87d52af73222d4a479ebe40b904ebabf543d4706240658e6092ca9388c26546001600160a01b031661098f565b6108c26117dc366004613c9e565b612ccc565b7f84b42b3d5e6851893d4418c6ebc9a4727e78afdf84e73674c8b9c1c2b1904e2d600052609a6020527f492656d26f3accf1cea0a783c131178deb1c8733d9c679e5cecde8df27a9ad95546001600160a01b031661098f565b610865611848366004613cb7565b60009182526065602090815260408084206001600160a01b0393909316845291905290205460ff1690565b6108a17f523a704056dcd17bcf83bed8b68c59416dac1119be77755efe3bde0a64e46e0c81565b6108c26118a8366004613c83565b612d20565b6108c26118bb366004613c83565b612d55565b7f76d62e541b8d573110ca3eb9003e96426f530422a76712d1356f6c6ce50541ca600052609a6020527f86012a00795dbb89a313ebfe1e3a458a84ce87cdb7c6a7971caf999119513627546001600160a01b031661098f565b7f602490b12960e59ddb584affd1da6cd5692f4455c1ba0cc4e865af81e111ebe2600052609a6020527fd54531c6bba5beed207277daa8e0e65bdfb6aece3f974fb0394154eb989d1d42546001600160a01b031661098f565b6108a1600081565b7f4c9466ca1bf288a7334a7494f09a0acc38ee31628eaf8c68b574b9f0ec22a9c1600052609a6020527f2df8b6a0a0cdef82de21edc971a252888647231024af6c12c533010687315b1f546001600160a01b031661098f565b6108a17f3d88d1233771c5c30791fb6805b7f91424dae1e5a68a57da846ca7ff83c6402981565b6108a17ff2b2ce40acf2de0c782cf3a34ddfe1f1f18b1f0871445156842424b1aab892ff81565b7ff2b2ce40acf2de0c782cf3a34ddfe1f1f18b1f0871445156842424b1aab892ff600052609a6020527feae7fb6a5077daea6981eaf0fe59b84a36dab662abe836ba550b12d44a2d7a20546001600160a01b031661098f565b6108c2611a88366004613c83565b612d8a565b7f5c00ec259bace293b50174e499c413ca897b4bcb54ed468b7e6bade51c6a9f96600052609a6020527fcda3409ebc466b6ac691341dcf169fdb28e448f6cf860239292340843aa52984546001600160a01b031661098f565b6108a17f8e96355022bb9b9f4d9d4e01fe2b58f45e78549c982c401c96f75f33c5de457e81565b610865611b1b366004613d0d565b6000908152609a60205260409020546001600160a01b0390811691161490565b7f6f8d0b773ad4970d3e7d47623dc9ce06a1b4fe833bf451d06a47e774f9acaa6360005260986020527f72873426992e590ffa79a15175a7f2c8cf191cf402b7484af189cd125376fcdc546108a1565b6108c2611b99366004613c83565b612dbf565b7fe5240448c78dfcff5bda4e4eed69ba9635df15d79da0e8a4cf889217106fa45b600052609a6020527fcce26741946f801b25ce3c49451d2dd729b689d4d0d23ea57849f6c666bb5ee3546001600160a01b031661098f565b6108a17fb18278bb399a7088b8b0b26f4896d5ebaba4497c611bbe9d43abe92d9a1fe83d81565b6108c2611c2c366004613c83565b612df4565b6108c2611c3f366004613c9e565b612e29565b6108a17f3c6dcff840f36f9818a73b67d9d00197362f63687bd52e3c277bd0ffb30dde3381565b6108c2611c79366004613c83565b612e7d565b6108a17f26b94d9446e6775a4c9592fb825e2f9b26930b186faaaa3fd1a7a3187875602081565b6108a17f690795c57e13eaf2526f76202b6799e9afdb069afca1e572f693953d013569d881565b6108c2611cda366004613c83565b612eb2565b7f09dfa94a9be22222b511ecf509f49718fc08fbe3ada37a44d2022489eca3b44c600052609b6020527fe98ed444639fcf7afa9e33a4ea67ac4155aa97d88f546111c8d1357c98dbca00546001600160a01b031661098f565b7f2cf2377da51daa9c0d7e3f98c7532a67ee5e9398afad7b7db6e578b978a2709460005260986020527f0ccceacf55cd457ff25dca300775a2cb43db2c0b890d3ee063f4abba210c504f546108a1565b6108c2611d96366004613cb7565b612ee7565b6108a17fdb5d1c2a9350ca010dcdf3953da11a9e8f7c5e2918cdfa65500e84e7fd4fde7d81565b7f9f919a2294d86593fbcec81ea71aa683cec51c78771c642f8894ba8f39497052600052609a6020527f99c8bd240e5bd2ee897b6a14ca3ca43a06f489dad5e38985ad188e67459dc6d7546001600160a01b031661098f565b7f95bf18d68834a11aaae7b73ff6037326f163a81a7b5ea80cba96856ce2284fbd600052609b6020527f20c8b2f4826823ac4cd62278270e8be9c7f63b9fe22e1f148f5369ec26bc69f4546001600160a01b031661098f565b6108c2611e82366004613c83565b612f0c565b6108c2611e95366004613c83565b612fad565b6108a17f46b41285bb7b8513ce3a9d95cdf6916699fb00b47326e8d3850be1b6186e034981565b7f3e4ded42f360c2e6b1251d584085ae1d9aa9cbed18687fac6b6aef8eed1c5ad3600052609a6020527fe298efc0f606c3be77912795055e173991a2c395633d4b0a06597a13b46e0c0b546001600160a01b031661098f565b7ff935b8bf66b325637ad32ca875b588849cf4026791b79b4dc20623cd3dd36e20600052609a6020527f18d210dd586fe31598c73b0131261a1f7a576051e2667bbf5a4f8a01cf2f1392546001600160a01b031661098f565b7f26b94d9446e6775a4c9592fb825e2f9b26930b186faaaa3fd1a7a31878756020600052609a6020527f9199539d2700b3c2608fddf97698233fa7a9b8abd3a8181087acd967d8f0de82546001600160a01b031661098f565b7f08593985ae1bebfb02f6c30105edffb176a6d87c9fad54c434bf9b58f67e81b660005260976020527fb645ae2edae7c0716931b638cd9631a05f9a39fec3f15294f7f3af49f2f51ca8546108a1565b6108a17f5c00ec259bace293b50174e499c413ca897b4bcb54ed468b7e6bade51c6a9f9681565b7ffa5a84fed05ba4c93fcc5ba1f4ad010e3bef3e6394b367aa10b3ec01997375cc60005260986020527f8489bc07817c82dd59579d43388f707a6a0a4a614b58e7df61bb06baec0de2c1546108a1565b6108c26120a1366004613c83565b612fe2565b6108a17f09dfa94a9be22222b511ecf509f49718fc08fbe3ada37a44d2022489eca3b44c81565b6108c26120db366004613c83565b613016565b7f876943525608da6d95be5925fe6c4fe80e8622c8a76e7414f80e8ba210e0711c60005260976020527fea561c0677f20715a0e74899b0381a0fa1265a58e9e02fb4a5a398d87555d1fe546108a1565b7ff822b1f0c3b886ce1cdf1c2a5317844145470db33b02c63cae4813f8c9b2dc1760005260976020527f9863915096f3522486953e53c4b97560d72679216b36fd98b4bdd4eca3a01eaa546108a1565b6108c261218e366004613c9e565b61304b565b60007fffffffff0000000000000000000000000000000000000000000000000000000082167f7965db0b00000000000000000000000000000000000000000000000000000000148061222657507f01ffc9a7000000000000000000000000000000000000000000000000000000007fffffffff000000000000000000000000000000000000000000000000000000008316145b92915050565b600061223781613080565b6122617fdb5d1c2a9350ca010dcdf3953da11a9e8f7c5e2918cdfa65500e84e7fd4fde7d8361308d565b5050565b600061227081613080565b6122617ff935b8bf66b325637ad32ca875b588849cf4026791b79b4dc20623cd3dd36e208361308d565b7faf290d8680820aad922855f39b306097b20e28774d6c1ad35a20325630c3a02c6122c481613080565b6122ee7f712c13b90acf399d7bc7625370ce37c64b5eba41011b0961a88c2ef1648870cf83613168565b6122616131f8565b600061230181613080565b6122617fc5b1a6a0b843563e6a17ca90bc59d2315c523be427d0c9c2ba08d77ced4f46b18361308d565b600061233681613080565b6122617f8e96355022bb9b9f4d9d4e01fe2b58f45e78549c982c401c96f75f33c5de457e8361308d565b600061236b81613080565b6122617f5be667ef1f4c6c279e2aa7e62595a1045043db6a43145cb438c6d36e7a3c3ed88361308d565b60006123a081613080565b6122617fd7e49a298cb2719de62e5df1024257eed316db6337361b3a30d56a75324046078361308d565b6000828152606560205260409020600101546123e581613080565b6123ef83836134ae565b505050565b60006123ff81613080565b6122617f5c00ec259bace293b50174e499c413ca897b4bcb54ed468b7e6bade51c6a9f968361308d565b6001600160a01b03811633146124c6576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602f60248201527f416363657373436f6e74726f6c3a2063616e206f6e6c792072656e6f756e636560448201527f20726f6c657320666f722073656c66000000000000000000000000000000000060648201526084015b60405180910390fd5b612261828261356e565b60006124db81613080565b6122617f3d88d1233771c5c30791fb6805b7f91424dae1e5a68a57da846ca7ff83c640298361308d565b600061251081613080565b6122617fa4083e7a78dd898def03c51ce199cb4286b8828be4f6f46e04aec617619674718361308d565b600061254581613080565b6122617f690795c57e13eaf2526f76202b6799e9afdb069afca1e572f693953d013569d88361308d565b600054610100900460ff161580801561258f5750600054600160ff909116105b806125a95750303b1580156125a9575060005460ff166001145b612635576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201527f647920696e697469616c697a656400000000000000000000000000000000000060648201526084016124bd565b600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00166001179055801561269357600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff166101001790555b61269c8361360f565b6126a58261360f565b6126ad61364f565b6126e07ff822b1f0c3b886ce1cdf1c2a5317844145470db33b02c63cae4813f8c9b2dc176801bc16d674ec8000006136e6565b6127127f9b1ae66636378b5626322a52e22518dd40bb04881cf0440ed16a20c0f902b242670de0b6b3a76400006136e6565b6127457f876943525608da6d95be5925fe6c4fe80e8622c8a76e7414f80e8ba210e0711c6801ae361fc1451c00006136e6565b6127717f33271b56873d8abb908de4853f90a8a0ef8829548ec0bf6c298feed3917c50a26127106136e6565b6127a37f08593985ae1bebfb02f6c30105edffb176a6d87c9fad54c434bf9b58f67e81b6670de0b6b3a76400006136e6565b6127ce7f59b5f464ec5829246a81f005456c8cb714ee224aea800742e2dae497263e466960ff6136e6565b6127fe7ffa5a84fed05ba4c93fcc5ba1f4ad010e3bef3e6394b367aa10b3ec01997375cc655af3107a4000613168565b6128327f712c13b90acf399d7bc7625370ce37c64b5eba41011b0961a88c2ef1648870cf69021e19e0c9bab2400000613168565b6128627fb18278bb399a7088b8b0b26f4896d5ebaba4497c611bbe9d43abe92d9a1fe83d655af3107a4000613168565b6128967f1c2fe98ddbbbffbcf7735c7446ffcddb5ccd2a4ec2ace0f7d90f73e9ff13fcc769021e19e0c9bab2400000613168565b6128c17f6f8d0b773ad4970d3e7d47623dc9ce06a1b4fe833bf451d06a47e774f9acaa636032613168565b6128ed7f2cf2377da51daa9c0d7e3f98c7532a67ee5e9398afad7b7db6e578b978a27094610258613168565b6129177f84b42b3d5e6851893d4418c6ebc9a4727e78afdf84e73674c8b9c1c2b1904e2d8361308d565b6129226000846134ae565b80156123ef57600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff169055604051600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a1505050565b6001600160a01b03811660009081527fd0adccafa00cb0c249f97d61c2e3d5481f50f73dd720c43f6abfd51bc514ae32602052604081205460ff16612226565b7faf290d8680820aad922855f39b306097b20e28774d6c1ad35a20325630c3a02c6129f381613080565b6122617f46b41285bb7b8513ce3a9d95cdf6916699fb00b47326e8d3850be1b6186e034983613168565b6000612a2881613080565b6122617fbd34382cd421c5250595893a4ed6cdb2125e6be7d5e0a9dbc469de5d583adfcf8361308d565b6000612a5d81613080565b6122ee7f1c2fe98ddbbbffbcf7735c7446ffcddb5ccd2a4ec2ace0f7d90f73e9ff13fcc783613168565b6000612a9281613080565b6122617f3e4ded42f360c2e6b1251d584085ae1d9aa9cbed18687fac6b6aef8eed1c5ad38361308d565b6001600160a01b03811660009081527f1e6786989dce539fea7d731d64b9cad71079fbf2317e57197327e4df37ed1b47602052604081205460ff16612226565b7faf290d8680820aad922855f39b306097b20e28774d6c1ad35a20325630c3a02c612b2681613080565b6122617f3c6dcff840f36f9818a73b67d9d00197362f63687bd52e3c277bd0ffb30dde3383613168565b6000612b5b81613080565b6122617fb134afa3abad633a84ab2d33dd5171f2b371e38b0f7bca001383aaf08ed6d2d18361308d565b6000612b9081613080565b6122617f2cf2377da51daa9c0d7e3f98c7532a67ee5e9398afad7b7db6e578b978a2709483613168565b7faf290d8680820aad922855f39b306097b20e28774d6c1ad35a20325630c3a02c612be481613080565b6122617f8567f5af844d68168987760a7ce1762804b9de703165fc50ce4fa85246016c9183613776565b6000612c1981613080565b6122617ff2b2ce40acf2de0c782cf3a34ddfe1f1f18b1f0871445156842424b1aab892ff8361308d565b6000612c4e81613080565b6122617f95bf18d68834a11aaae7b73ff6037326f163a81a7b5ea80cba96856ce2284fbd83613849565b7faf290d8680820aad922855f39b306097b20e28774d6c1ad35a20325630c3a02c612ca281613080565b6122ee7ffa5a84fed05ba4c93fcc5ba1f4ad010e3bef3e6394b367aa10b3ec01997375cc83613168565b7faf290d8680820aad922855f39b306097b20e28774d6c1ad35a20325630c3a02c612cf681613080565b6122617fc54a7590fe6738d7a81f393c1cf5ab3e577c91781037d93a5a9f5ce44f19eb5183613168565b6000612d2b81613080565b6122617f8d4341681b282735dd0d55670ff8e0ad68a80cbfc2cee847065e9f771470f88f8361308d565b6000612d6081613080565b6122617f26b94d9446e6775a4c9592fb825e2f9b26930b186faaaa3fd1a7a318787560208361308d565b6000612d9581613080565b6122617fe5240448c78dfcff5bda4e4eed69ba9635df15d79da0e8a4cf889217106fa45b8361308d565b6000612dca81613080565b6122617f602490b12960e59ddb584affd1da6cd5692f4455c1ba0cc4e865af81e111ebe28361308d565b6000612dff81613080565b6122617f09dfa94a9be22222b511ecf509f49718fc08fbe3ada37a44d2022489eca3b44c83613849565b7f523a704056dcd17bcf83bed8b68c59416dac1119be77755efe3bde0a64e46e0c612e5381613080565b6122617f6f8d0b773ad4970d3e7d47623dc9ce06a1b4fe833bf451d06a47e774f9acaa6383613168565b6000612e8881613080565b6122617f76d62e541b8d573110ca3eb9003e96426f530422a76712d1356f6c6ce50541ca8361308d565b6000612ebd81613080565b6122617f9f919a2294d86593fbcec81ea71aa683cec51c78771c642f8894ba8f394970528361308d565b600082815260656020526040902060010154612f0281613080565b6123ef838361356e565b6000612f1781613080565b7fdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42600090815260996020527f15be86566e203c1f41b9ae149d9fbb01b2c14f503704423d739a6e3d2db5a9ee546001600160a01b031690612f7890846134ae565b612fa27fdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec4284613776565b6123ef60008261356e565b6000612fb881613080565b6122617f4c9466ca1bf288a7334a7494f09a0acc38ee31628eaf8c68b574b9f0ec22a9c18361308d565b6000612fed81613080565b6122617e665c1b06e0667c56a1ca1706b7573435d1b9162c6327b5d0ea1daeb491ad0d8361308d565b600061302181613080565b6122617f29384ec8473b541e7a7850226a4d1906a700f14cc394266ee08800ba62dc3af98361308d565b600061305681613080565b6122ee7fb18278bb399a7088b8b0b26f4896d5ebaba4497c611bbe9d43abe92d9a1fe83d83613168565b61308a813361391c565b50565b6130968161360f565b6000828152609a60205260409020546001600160a01b038083169116036130e9576040517fb5ca7aab00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000828152609a602090815260409182902080547fffffffffffffffffffffffff0000000000000000000000000000000000000000166001600160a01b0385169081179091558251858152918201527f5de40a806536a2029221dac2c8887ac9f11952fcc1ed3d7cfb4476dd5259b74091015b60405180910390a15050565b6000828152609860205260409020548190036131b0576040517fb5ca7aab00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60008281526098602090815260409182902083905581518481529081018390527f9094260c4234c0cb4c44e4a035abb5816b84e5505f9dc571c3ff397c46581630910161315c565b7ffa5a84fed05ba4c93fcc5ba1f4ad010e3bef3e6394b367aa10b3ec01997375cc60005260986020527f8489bc07817c82dd59579d43388f707a6a0a4a614b58e7df61bb06baec0de2c1541580159061329a57507fb18278bb399a7088b8b0b26f4896d5ebaba4497c611bbe9d43abe92d9a1fe83d60005260986020527f8f1b9b075a455aa4e85ab4edea73c8fe6d4e2e5e4c6675d6135fefdca5e95a255415155b8015613311575060986020527ffcacc1044a5a1b4eb9c058396306426a857813d37a4fb6ccf5a3adde30e0c914547ffa5a84fed05ba4c93fcc5ba1f4ad010e3bef3e6394b367aa10b3ec01997375cc6000527f8489bc07817c82dd59579d43388f707a6a0a4a614b58e7df61bb06baec0de2c15411155b8015613388575060986020527fd179a4a9329ee39fba707fd91c699ec0f088afc56731eb89ff424b873ac70844547fb18278bb399a7088b8b0b26f4896d5ebaba4497c611bbe9d43abe92d9a1fe83d6000527f8f1b9b075a455aa4e85ab4edea73c8fe6d4e2e5e4c6675d6135fefdca5e95a255411155b80156133ff575060986020527f8489bc07817c82dd59579d43388f707a6a0a4a614b58e7df61bb06baec0de2c1547fb18278bb399a7088b8b0b26f4896d5ebaba4497c611bbe9d43abe92d9a1fe83d6000527f8f1b9b075a455aa4e85ab4edea73c8fe6d4e2e5e4c6675d6135fefdca5e95a255411155b8015613476575060986020527ffcacc1044a5a1b4eb9c058396306426a857813d37a4fb6ccf5a3adde30e0c914547f1c2fe98ddbbbffbcf7735c7446ffcddb5ccd2a4ec2ace0f7d90f73e9ff13fcc76000527fd179a4a9329ee39fba707fd91c699ec0f088afc56731eb89ff424b873ac708445410155b6134ac576040517fe773e0a900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b565b60008281526065602090815260408083206001600160a01b038516845290915290205460ff166122615760008281526065602090815260408083206001600160a01b0385168452909152902080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0016600117905561352a3390565b6001600160a01b0316816001600160a01b0316837f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d60405160405180910390a45050565b60008281526065602090815260408083206001600160a01b038516845290915290205460ff16156122615760008281526065602090815260408083206001600160a01b038516808552925280832080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0016905551339285917ff6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b9190a45050565b6001600160a01b03811661308a576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600054610100900460ff166134ac576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e6700000000000000000000000000000000000000000060648201526084016124bd565b60008281526097602052604090205481900361372e576040517fb5ca7aab00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60008281526097602090815260409182902083905581518481529081018390527f9094260c4234c0cb4c44e4a035abb5816b84e5505f9dc571c3ff397c46581630910161315c565b61377f8161360f565b6000828152609960205260409020546001600160a01b038083169116036137d2576040517fb5ca7aab00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60008281526099602090815260409182902080547fffffffffffffffffffffffff0000000000000000000000000000000000000000166001600160a01b0385169081179091558251858152918201527fcbdd341876786c7241ad12a5ce5ea46739a4ce7b1587d0c216dfa655a98e50a6910161315c565b6138528161360f565b6000828152609b60205260409020546001600160a01b038083169116036138a5576040517fb5ca7aab00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000828152609b602090815260409182902080547fffffffffffffffffffffffff0000000000000000000000000000000000000000166001600160a01b0385169081179091558251858152918201527f19aab10c6a9f5d648eaa15e2d515f8dfda570ee221e7c8cb9dc07694e68005bc910161315c565b60008281526065602090815260408083206001600160a01b038516845290915290205460ff166122615761394f816139c9565b61395a8360206139db565b60405160200161396b929190613d5b565b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0818403018152908290527f08c379a00000000000000000000000000000000000000000000000000000000082526124bd91600401613ddc565b60606122266001600160a01b03831660145b606060006139ea836002613e5c565b6139f5906002613e99565b67ffffffffffffffff811115613a0d57613a0d613eac565b6040519080825280601f01601f191660200182016040528015613a37576020820181803683370190505b5090507f300000000000000000000000000000000000000000000000000000000000000081600081518110613a6e57613a6e613edb565b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a9053507f780000000000000000000000000000000000000000000000000000000000000081600181518110613ad157613ad1613edb565b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a9053506000613b0d846002613e5c565b613b18906001613e99565b90505b6001811115613bb5577f303132333435363738396162636465660000000000000000000000000000000085600f1660108110613b5957613b59613edb565b1a60f81b828281518110613b6f57613b6f613edb565b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a90535060049490941c93613bae81613f0a565b9050613b1b565b508315613c1e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f537472696e67733a20686578206c656e67746820696e73756666696369656e7460448201526064016124bd565b9392505050565b600060208284031215613c3757600080fd5b81357fffffffff0000000000000000000000000000000000000000000000000000000081168114613c1e57600080fd5b80356001600160a01b0381168114613c7e57600080fd5b919050565b600060208284031215613c9557600080fd5b613c1e82613c67565b600060208284031215613cb057600080fd5b5035919050565b60008060408385031215613cca57600080fd5b82359150613cda60208401613c67565b90509250929050565b60008060408385031215613cf657600080fd5b613cff83613c67565b9150613cda60208401613c67565b60008060408385031215613d2057600080fd5b613d2983613c67565b946020939093013593505050565b60005b83811015613d52578181015183820152602001613d3a565b50506000910152565b7f416363657373436f6e74726f6c3a206163636f756e7420000000000000000000815260008351613d93816017850160208801613d37565b7f206973206d697373696e6720726f6c65200000000000000000000000000000006017918401918201528351613dd0816028840160208801613d37565b01602801949350505050565b6020815260008251806020840152613dfb816040850160208701613d37565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169190910160400192915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b6000817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0483118215151615613e9457613e94613e2d565b500290565b8082018082111561222657612226613e2d565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b600081613f1957613f19613e2d565b507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff019056fea26469706673582212201fb7833c1fb9b0e3051e5dba297b2540cc7cce13c70f80ed8799163f77d34b8764736f6c63430008100033