Contract Address Details

// SPDX-License-Identifier: Apache 2.0
pragma solidity =0.8.25;
import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import { Initializable } from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import { OwnableUpgradeable } from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import { IConnectivityTrackerHbbft } from "./interfaces/IConnectivityTrackerHbbft.sol";
import { IValidatorSetHbbft } from "./interfaces/IValidatorSetHbbft.sol";
import { IStakingHbbft } from "./interfaces/IStakingHbbft.sol";
import { IBlockRewardHbbft } from "./interfaces/IBlockRewardHbbft.sol";
import { IBonusScoreSystem } from "./interfaces/IBonusScoreSystem.sol";
import { Unauthorized, ZeroAddress } from "./lib/Errors.sol";
import { ValueGuards } from "./lib/ValueGuards.sol";
contract ConnectivityTrackerHbbft is Initializable, OwnableUpgradeable, IConnectivityTrackerHbbft, ValueGuards {
    using EnumerableSet for EnumerableSet.AddressSet;
    /**
     * @dev The address of the {ValidatorSetHbbft} contract.
     */
    IValidatorSetHbbft public validatorSetContract;
    /**
     * @dev The address of the {StakingHbbft} contract.
     */
    IStakingHbbft public stakingContract;
    /**
     * @dev The address of the {BlockRewardHbbft} contract.
     */
    IBlockRewardHbbft public blockRewardContract;
    /**
     * @dev Time since the beginning of the epoch during which reports are not accepted.
     * @custom:oz-renamed-from minReportAgeBlocks
     */
    uint256 public reportDisallowPeriod;
    /**
     * @dev Parameter that binds Hbbft Fault tolerance with
     */
    uint256 public earlyEpochEndToleranceLevel;
    /**
     * @dev Early epoch end historical data.
     */
    mapping(uint256 => bool) public isEarlyEpochEnd;
    /**
     * @dev Mapping the epoch number to the list of validators that have disconnected in it.
     */
    mapping(uint256 => EnumerableSet.AddressSet) private _flaggedValidators;
    /**
     * @dev Mapping of reported validators and their reporters by epoch number.
     */
    mapping(uint256 => mapping(address => EnumerableSet.AddressSet)) private _reporters;
    /**
     * @dev Indicats wheter validators were penalised for bad performance in specific epoch.
     */
    mapping(uint256 => bool) private _epochPenaltiesSent;
    /**
     * @dev The address of the {BonusScoreSystem} contract.
     */
    IBonusScoreSystem public bonusScoreContract;
    /**
     * @dev Timestamp when the validator was marked as faulty in a specific epoch.
     */
    mapping(uint256 => mapping(address => uint256)) private _disconnectTimestamp;
    /**
     * @dev Emitted by the {setReportDisallowPeriod} function.
     * @param _reportDisallowPeriodSeconds New report disallow period value in seconds.
     */
    event SetReportDisallowPeriod(uint256 _reportDisallowPeriodSeconds);
    /**
     * @dev Emitted when `validator` was reported by `reporter` for lost connection at block `blockNumber`.
     * @param reporter Reporting validator address.
     * @param validator Address of the validator with which the connection was lost.
     * @param blockNumber Block number when connection was lost.
     */
    event ReportMissingConnectivity(address indexed reporter, address indexed validator, uint256 indexed blockNumber);
    /**
     * @dev Emitted when `validator` was reported by `reporter` as reconnected at block `blockNumber`.
     * @param reporter Reporting validator address.
     * @param validator Address of the reconnected validator.
     * @param blockNumber Block number when reported validator reconnected.
     */
    event ReportReconnect(address indexed reporter, address indexed validator, uint256 indexed blockNumber);
    /**
     * @dev Emitted to signal that the count of disconnected validators exceeded
     * the threshold and current epoch `epoch` will end earlier.
     * @param epoch Staking epoch number.
     * @param blockNumber Block number in which the decision was made.
     */
    event NotifyEarlyEpochEnd(uint256 indexed epoch, uint256 indexed blockNumber);
    error AlreadyReported(address reporter, address validator);
    error CannotReportByFlaggedValidator(address reporter);
    error InvalidBlock();
    error OnlyValidator();
    error ReportTooEarly();
    error UnknownReconnectReporter(address reporter, address validator);
    error EpochPenaltiesAlreadySent(uint256 epoch);
    /**
     * @custom:oz-upgrades-unsafe-allow constructor
     */
    constructor() {
        // Prevents initialization of implementation contract
        _disableInitializers();
    }
    /**
     * @dev Check that the caller is {BlockRewardHbbft} contract.
     *
     * Reverts with an {Unauthorized} error.
     */
    modifier onlyBlockRewardContract() {
        if (msg.sender != address(blockRewardContract)) {
            revert Unauthorized();
        }
        _;
    }
    function initialize(
        address _contractOwner,
        address _validatorSetContract,
        address _stakingContract,
        address _blockRewardContract,
        address _bonusScoreContract,
        uint256 _reportDisallowPeriodSeconds
    ) external initializer {
        if (
            _contractOwner == address(0) ||
            _validatorSetContract == address(0) ||
            _stakingContract == address(0) ||
            _blockRewardContract == address(0) ||
            _bonusScoreContract == address(0)
        ) {
            revert ZeroAddress();
        }
        __Ownable_init(_contractOwner);
        validatorSetContract = IValidatorSetHbbft(_validatorSetContract);
        stakingContract = IStakingHbbft(_stakingContract);
        blockRewardContract = IBlockRewardHbbft(_blockRewardContract);
        bonusScoreContract = IBonusScoreSystem(_bonusScoreContract);
        reportDisallowPeriod = _reportDisallowPeriodSeconds;
        earlyEpochEndToleranceLevel = 2;
        uint256 step = 3 minutes;
        uint256[] memory reportDisallowPeriodAllowedParams = new uint256[](10);
        for (uint256 i = 0; i < 10; i++) {
            reportDisallowPeriodAllowedParams[i] = step + (i * step);
        }
        __initAllowedChangeableParameter(
            this.setReportDisallowPeriod.selector,
            this.reportDisallowPeriod.selector,
            reportDisallowPeriodAllowedParams
        );
    }
    /**
     * @dev This function sets the period of time during which reports are not accepted.
     * Can only be called by contract owner.
     * @param _reportDisallowPeriodSeconds Time period in seconds.
     *
     * Emits a {SetReportDisallowPeriod} event.
     */
    function setReportDisallowPeriod(uint256 _reportDisallowPeriodSeconds) external onlyOwner withinAllowedRange(_reportDisallowPeriodSeconds) {
        reportDisallowPeriod = _reportDisallowPeriodSeconds;
        emit SetReportDisallowPeriod(_reportDisallowPeriodSeconds);
    }
    /**
     * @dev Report that the connection to the specified validator was lost at block `blockNumber`.
     * Callable only by active validators.
     *
     * @param validator Validator address with which the connection was lost.
     * @param blockNumber Block number where the connection was lost.
     * @param blockHash Hash of this block.
     *
     * Emits a {ReportMissingConnectivity} event.
     */
    function reportMissingConnectivity(address validator, uint256 blockNumber, bytes32 blockHash) external {
        checkReportMissingConnectivityCallable(msg.sender, validator, blockNumber, blockHash);
        uint256 epoch = currentEpoch();
        uint256 currentScore = getValidatorConnectivityScore(epoch, validator);
        if (currentScore == 0) {
            // slither-disable-next-line unused-return
            _flaggedValidators[epoch].add(validator);
        }
        // slither-disable-next-line unused-return
        _reporters[epoch][validator].add(msg.sender);
        if (isFaultyValidator(epoch, validator)) {
            _markValidatorFaulty(epoch, validator);
        }
        _decideEarlyEpochEndNeeded(epoch);
        emit ReportMissingConnectivity(msg.sender, validator, blockNumber);
    }
    /**
     * @dev Report that the connection to the specified validator was restored at block `blockNumber`.
     * Callable only by active validators.
     *
     * @param validator Validator address with which the connection was restored.
     * @param blockNumber Block number where the connection was restored.
     * @param blockHash Hash of this block.
     *
     * Emits a {ReportReconnect} event.
     */
    function reportReconnect(address validator, uint256 blockNumber, bytes32 blockHash) external {
        checkReportReconnectCallable(msg.sender, validator, blockNumber, blockHash);
        uint256 epoch = currentEpoch();
        uint256 currentScore = getValidatorConnectivityScore(epoch, validator);
        // slither-disable-next-line unused-return
        _reporters[epoch][validator].remove(msg.sender);
        if (currentScore == 1) {
            // slither-disable-next-line unused-return
            _flaggedValidators[epoch].remove(validator);
            // All reporters confirmed that this validator reconnected,
            // decrease validator bonus score for bad performance based on disconnect time interval.
            uint256 disconnectTimestamp = _disconnectTimestamp[epoch][validator];
            if (disconnectTimestamp != 0) {
                uint256 disconnectPeriod = block.timestamp - disconnectTimestamp;
                bonusScoreContract.penaliseBadPerformance(validator, disconnectPeriod);
                delete _disconnectTimestamp[epoch][validator];
            }
        }
        _decideEarlyEpochEndNeeded(epoch);
        emit ReportReconnect(msg.sender, validator, blockNumber);
    }
    /**
     * @dev Send bad performance bonus score penalties to validators
     * that have not yet reconnected at the end of the epoch.
     * Can only be called by {BlockRewardHbbft} contract.
     *
     * @param epoch Staking epoch number.
     *
     * Reverts with {EpochPenaltiesAlreadySent} if penalties for specified `epoch` already sent.
     */
    function penaliseFaultyValidators(uint256 epoch) external onlyBlockRewardContract {
        if (_epochPenaltiesSent[epoch]) {
            revert EpochPenaltiesAlreadySent(epoch);
        }
        _epochPenaltiesSent[epoch] = true;
        address[] memory flaggedValidators = getFlaggedValidatorsByEpoch(epoch);
        for (uint256 i = 0; i < flaggedValidators.length; ++i) {
            if (!isFaultyValidator(epoch, flaggedValidators[i])) {
                continue;
            }
            bonusScoreContract.penaliseBadPerformance(flaggedValidators[i], 0);
        }
    }
    /**
     * @dev Returns true if the validator `validator` was reported
     * by the specified `reporter`at the current epoch.
     * @param validator Valdiator address.
     * @param reporter Reporting validator address.
     */
    function isReported(uint256, address validator, address reporter) external view returns (bool) {
        return _reporters[currentEpoch()][validator].contains(reporter);
    }
    function getValidatorConnectivityScore(uint256 epoch, address validator) public view returns (uint256) {
        return _reporters[epoch][validator].length();
    }
    /**
     * @dev Returns true if the validator `validator` was marked as faulty
     * (majority of other validators reported missing connectivity) in the specified `epoch`.
     * @param epoch Staking epoch number.
     * @param validator Validator address
     */
    function isFaultyValidator(uint256 epoch, address validator) public view returns (bool) {
        return getValidatorConnectivityScore(epoch, validator) >= _getReportersThreshold(epoch);
    }
    function checkReportMissingConnectivityCallable(
        address caller,
        address validator,
        uint256 blockNumber,
        bytes32 blockHash
    ) public view {
        uint256 epoch = currentEpoch();
        _validateParams(epoch, caller, blockNumber, blockHash);
        if (_reporters[epoch][validator].contains(caller)) {
            revert AlreadyReported(caller, validator);
        }
    }
    function checkReportReconnectCallable(
        address caller,
        address validator,
        uint256 blockNumber,
        bytes32 blockHash
    ) public view {
        uint256 epoch = currentEpoch();
        _validateParams(epoch, caller, blockNumber, blockHash);
        // Only "missing connectivity" reporter can also report reconnect
        if (!_reporters[epoch][validator].contains(caller)) {
            revert UnknownReconnectReporter(caller, validator);
        }
    }
    /**
     * @dev Get list of validators flagged for missing connectivity in the specified `epoch`.
     * @param epoch Staking epoch number.
     */
    function getFlaggedValidatorsByEpoch(uint256 epoch) public view returns (address[] memory) {
        return _flaggedValidators[epoch].values();
    }
    /**
     * @dev Get list of validators flagged for missing connectivity in the current epoch.
     * See {getFlaggedValidatorsByEpoch}.
     */
    function getFlaggedValidators() public view returns (address[] memory) {
        return getFlaggedValidatorsByEpoch(currentEpoch());
    }
    /**
     * @dev Get list of validators flagged for missing connectivity in the specified staking epoch `epoch`.
     * @param epoch Staking epoch number.
     */
    function getFlaggedValidatorsCount(uint256 epoch) public view returns (uint256) {
        return _flaggedValidators[epoch].length();
    }
    /**
     * @dev Get current staking epoch number.
     * See {StakingHbbft-stakingEpoch}
     */
    function currentEpoch() public view returns (uint256) {
        return IStakingHbbft(stakingContract).stakingEpoch();
    }
    /**
     * @dev Returns the number of validators that, if exceeded,
     * will trigger an early end of the current staking epoch.
     */
    function earlyEpochEndThreshold() public view returns (uint256) {
        uint256 networkSize = IValidatorSetHbbft(validatorSetContract).getCurrentValidatorsCount();
        uint256 hbbftFaultTolerance = networkSize / 3;
        if (hbbftFaultTolerance <= earlyEpochEndToleranceLevel) {
            return 0;
        } else {
            return hbbftFaultTolerance - earlyEpochEndToleranceLevel;
        }
    }
    /**
     * @dev Returns faulty validators count in given epoch `epoch`.
     * @param epoch Staking epoch number.
     */
    function countFaultyValidators(uint256 epoch) public view returns (uint256) {
        return _countFaultyValidators(epoch);
    }
    function _decideEarlyEpochEndNeeded(uint256 epoch) private {
        // skip checks since notification has already been sent
        if (isEarlyEpochEnd[epoch]) {
            return;
        }
        uint256 threshold = earlyEpochEndThreshold();
        uint256 faultyValidatorsCount = _countFaultyValidators(epoch);
        // threshold has not been passed
        if (faultyValidatorsCount < threshold) {
            return;
        }
        isEarlyEpochEnd[epoch] = true;
        blockRewardContract.notifyEarlyEpochEnd();
        emit NotifyEarlyEpochEnd(epoch, block.number);
    }
    function _markValidatorFaulty(uint256 epoch, address validator) private {
        if (_disconnectTimestamp[epoch][validator] != 0) {
            // validator already marked as faulty
            return;
        }
        _disconnectTimestamp[epoch][validator] = block.timestamp;
        validatorSetContract.notifyUnavailability(validator);
    }
    function _getReportersThreshold(uint256 epoch) private view returns (uint256) {
        uint256 unflaggedValidatorsCount = validatorSetContract.getCurrentValidatorsCount() -
            getFlaggedValidatorsCount(epoch);
        return (2 * unflaggedValidatorsCount) / 3 + 1;
    }
    function _countFaultyValidators(uint256 epoch) private view returns (uint256) {
        uint256 reportersThreshold = _getReportersThreshold(epoch);
        uint256 result = 0;
        address[] memory flaggedValidators = getFlaggedValidatorsByEpoch(epoch);
        for (uint256 i = 0; i < flaggedValidators.length; ++i) {
            address validator = flaggedValidators[i];
            if (getValidatorConnectivityScore(epoch, validator) >= reportersThreshold) {
                ++result;
            }
        }
        return result;
    }
    function _validateParams(uint256 epoch, address caller, uint256 blockNumber, bytes32 blockHash) private view {
        if (!validatorSetContract.isValidator(caller)) {
            revert OnlyValidator();
        }
        if (blockNumber > block.number || blockhash(blockNumber) != blockHash) {
            revert InvalidBlock();
        }
        if (_flaggedValidators[epoch].contains(caller)) {
            revert CannotReportByFlaggedValidator(caller);
        }
        uint256 epochStartTimestamp = stakingContract.stakingEpochStartTime();
        if (block.timestamp < epochStartTimestamp + reportDisallowPeriod) {
            revert ReportTooEarly();
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)
pragma solidity ^0.8.20;
import {ContextUpgradeable} from "../utils/ContextUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
    /// @custom:storage-location erc7201:openzeppelin.storage.Ownable
    struct OwnableStorage {
        address _owner;
    }
    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Ownable")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant OwnableStorageLocation = 0x9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c199300;
    function _getOwnableStorage() private pure returns (OwnableStorage storage $) {
        assembly {
            $.slot := OwnableStorageLocation
        }
    }
    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);
    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    function __Ownable_init(address initialOwner) internal onlyInitializing {
        __Ownable_init_unchained(initialOwner);
    }
    function __Ownable_init_unchained(address initialOwner) internal onlyInitializing {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }
    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }
    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        OwnableStorage storage $ = _getOwnableStorage();
        return $._owner;
    }
    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }
    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }
    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }
    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        OwnableStorage storage $ = _getOwnableStorage();
        address oldOwner = $._owner;
        $._owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol)
pragma solidity ^0.8.20;
/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
 * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
 * case an upgrade adds a module that needs to be initialized.
 *
 * For example:
 *
 * [.hljs-theme-light.nopadding]
 * ```solidity
 * contract MyToken is ERC20Upgradeable {
 *     function initialize() initializer public {
 *         __ERC20_init("MyToken", "MTK");
 *     }
 * }
 *
 * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
 *     function initializeV2() reinitializer(2) public {
 *         __ERC20Permit_init("MyToken");
 *     }
 * }
 * ```
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
 * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() {
 *     _disableInitializers();
 * }
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev Storage of the initializable contract.
     *
     * It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions
     * when using with upgradeable contracts.
     *
     * @custom:storage-location erc7201:openzeppelin.storage.Initializable
     */
    struct InitializableStorage {
        /**
         * @dev Indicates that the contract has been initialized.
         */
        uint64 _initialized;
        /**
         * @dev Indicates that the contract is in the process of being initialized.
         */
        bool _initializing;
    }
    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Initializable")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;
    /**
     * @dev The contract is already initialized.
     */
    error InvalidInitialization();
    /**
     * @dev The contract is not initializing.
     */
    error NotInitializing();
    /**
     * @dev Triggered when the contract has been initialized or reinitialized.
     */
    event Initialized(uint64 version);
    /**
     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
     * `onlyInitializing` functions can be used to initialize parent contracts.
     *
     * Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any
     * number of times. This behavior in the constructor can be useful during testing and is not expected to be used in
     * production.
     *
     * Emits an {Initialized} event.
     */
    modifier initializer() {
        // solhint-disable-next-line var-name-mixedcase
        InitializableStorage storage $ = _getInitializableStorage();
        // Cache values to avoid duplicated sloads
        bool isTopLevelCall = !$._initializing;
        uint64 initialized = $._initialized;
        // Allowed calls:
        // - initialSetup: the contract is not in the initializing state and no previous version was
        //                 initialized
        // - construction: the contract is initialized at version 1 (no reininitialization) and the
        //                 current contract is just being deployed
        bool initialSetup = initialized == 0 && isTopLevelCall;
        bool construction = initialized == 1 && address(this).code.length == 0;
        if (!initialSetup && !construction) {
            revert InvalidInitialization();
        }
        $._initialized = 1;
        if (isTopLevelCall) {
            $._initializing = true;
        }
        _;
        if (isTopLevelCall) {
            $._initializing = false;
            emit Initialized(1);
        }
    }
    /**
     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
     * used to initialize parent contracts.
     *
     * A reinitializer may be used after the original initialization step. This is essential to configure modules that
     * are added through upgrades and that require initialization.
     *
     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
     * cannot be nested. If one is invoked in the context of another, execution will revert.
     *
     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
     * a contract, executing them in the right order is up to the developer or operator.
     *
     * WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization.
     *
     * Emits an {Initialized} event.
     */
    modifier reinitializer(uint64 version) {
        // solhint-disable-next-line var-name-mixedcase
        InitializableStorage storage $ = _getInitializableStorage();
        if ($._initializing || $._initialized >= version) {
            revert InvalidInitialization();
        }
        $._initialized = version;
        $._initializing = true;
        _;
        $._initializing = false;
        emit Initialized(version);
    }
    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {initializer} and {reinitializer} modifiers, directly or indirectly.
     */
    modifier onlyInitializing() {
        _checkInitializing();
        _;
    }
    /**
     * @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.
     */
    function _checkInitializing() internal view virtual {
        if (!_isInitializing()) {
            revert NotInitializing();
        }
    }
    /**
     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
     * through proxies.
     *
     * Emits an {Initialized} event the first time it is successfully executed.
     */
    function _disableInitializers() internal virtual {
        // solhint-disable-next-line var-name-mixedcase
        InitializableStorage storage $ = _getInitializableStorage();
        if ($._initializing) {
            revert InvalidInitialization();
        }
        if ($._initialized != type(uint64).max) {
            $._initialized = type(uint64).max;
            emit Initialized(type(uint64).max);
        }
    }
    /**
     * @dev Returns the highest version that has been initialized. See {reinitializer}.
     */
    function _getInitializedVersion() internal view returns (uint64) {
        return _getInitializableStorage()._initialized;
    }
    /**
     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
     */
    function _isInitializing() internal view returns (bool) {
        return _getInitializableStorage()._initializing;
    }
    /**
     * @dev Returns a pointer to the storage namespace.
     */
    // solhint-disable-next-line var-name-mixedcase
    function _getInitializableStorage() private pure returns (InitializableStorage storage $) {
        assembly {
            $.slot := INITIALIZABLE_STORAGE
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)
pragma solidity ^0.8.20;
import {Initializable} from "../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;
    }
    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.
pragma solidity ^0.8.20;
/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```solidity
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.
    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position is the index of the value in the `values` array plus 1.
        // Position 0 is used to mean a value is not in the set.
        mapping(bytes32 value => uint256) _positions;
    }
    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._positions[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }
    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We cache the value's position to prevent multiple reads from the same storage slot
        uint256 position = set._positions[value];
        if (position != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.
            uint256 valueIndex = position - 1;
            uint256 lastIndex = set._values.length - 1;
            if (valueIndex != lastIndex) {
                bytes32 lastValue = set._values[lastIndex];
                // Move the lastValue to the index where the value to delete is
                set._values[valueIndex] = lastValue;
                // Update the tracked position of the lastValue (that was just moved)
                set._positions[lastValue] = position;
            }
            // Delete the slot where the moved value was stored
            set._values.pop();
            // Delete the tracked position for the deleted slot
            delete set._positions[value];
            return true;
        } else {
            return false;
        }
    }
    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._positions[value] != 0;
    }
    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }
    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }
    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }
    // Bytes32Set
    struct Bytes32Set {
        Set _inner;
    }
    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }
    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }
    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }
    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }
    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }
    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;
        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }
        return result;
    }
    // AddressSet
    struct AddressSet {
        Set _inner;
    }
    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }
    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }
    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }
    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }
    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }
    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;
        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }
        return result;
    }
    // UintSet
    struct UintSet {
        Set _inner;
    }
    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }
    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }
    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }
    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }
    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }
    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;
        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }
        return result;
    }
}

// SPDX-License-Identifier: Apache 2.0
pragma solidity =0.8.25;
interface IBlockRewardHbbft {
    function addToReinsertPot() external payable;
    function notifyEarlyEpochEnd() external;
    function getGovernanceAddress() external view returns (address);
}

// SPDX-License-Identifier: Apache 2.0
pragma solidity =0.8.25;
enum ScoringFactor {
    StandByBonus,
    NoStandByPenalty,
    NoKeyWritePenalty,
    BadPerformancePenalty
}
interface IBonusScoreSystem {
    function getValidatorScore(address mining) external view returns (uint256);
    function rewardStandBy(address mining, uint256 time) external;
    function penaliseNoStandBy(address mining, uint256 time) external;
    function penaliseNoKeyWrite(address mining) external;
    function penaliseBadPerformance(address mining, uint256 time) external;
}

// SPDX-License-Identifier: Apache 2.0
pragma solidity =0.8.25;
interface IConnectivityTrackerHbbft {
    function reportMissingConnectivity(
        address validator,
        uint256 blockNum,
        bytes32 blockHash
    ) external;
    function reportReconnect(
        address validator,
        uint256 blockNumber,
        bytes32 blockHash
    ) external;
    function checkReportMissingConnectivityCallable(
        address caller,
        address validator,
        uint256 blockNumber,
        bytes32 blockHash
    ) external view;
    function checkReportReconnectCallable(
        address caller,
        address validator,
        uint256 blockNumber,
        bytes32 blockHash
    ) external view;
    function isEarlyEpochEnd(uint256 epoch) external view returns (bool);
    function penaliseFaultyValidators(uint256 epoch) external;
}

// SPDX-License-Identifier: Apache 2.0
pragma solidity =0.8.25;
interface IStakingHbbft {
    struct PoolRewardShares {
        uint256 validatorShare;
        uint256 nodeOperatorShare;
        uint256 delegatorsShare;
    }
    struct StakingParams {
        address _validatorSetContract;
        address _bonusScoreContract;
        address[] _initialStakingAddresses;
        uint256 _delegatorMinStake;
        uint256 _candidateMinStake;
        uint256 _maxStake;
        uint256 _stakingFixedEpochDuration;
        uint256 _stakingTransitionTimeframeLength;
        uint256 _stakingWithdrawDisallowPeriod;
    }
    function incrementStakingEpoch() external;
    function removePool(address) external;
    function removePools() external;
    function setStakingEpochStartTime(uint256) external;
    function notifyKeyGenFailed() external;
    function notifyAvailability(address _stakingAddress) external;
    function notifyNetworkOfftimeDetected(uint256) external;
    function updatePoolLikelihood(address mining, uint256 validatorScore) external;
    function getPoolPublicKey(address _poolAddress)
        external
        view
        returns (bytes memory);
    function getPoolsLikelihood()
        external
        view
        returns (uint256[] memory, uint256);
    function getPoolsToBeElected() external view returns (address[] memory);
    function getPoolsToBeRemoved() external view returns (address[] memory);
    function getPoolsInactive() external view returns (address[] memory);
    function isPoolActive(address) external view returns (bool);
    function isPoolValid(address) external view returns (bool);
    function MAX_CANDIDATES() external pure returns (uint256); // solhint-disable-line func-name-mixedcase
    function orderedWithdrawAmount(address, address)
        external
        view
        returns (uint256);
    function poolDelegators(address) external view returns (address[] memory);
    function setValidatorInternetAddress(
        address,
        bytes16,
        bytes2
    ) external;
    function stakeAmount(address, address) external view returns (uint256);
    function stakeAmountTotal(address) external view returns (uint256);
    function totalStakedAmount() external view returns (uint256);
    function stakingWithdrawDisallowPeriod() external view returns (uint256);
    function stakingEpoch() external view returns (uint256);
    function stakingFixedEpochDuration() external view returns (uint256);
    function startTimeOfNextPhaseTransition() external view returns (uint256);
    function stakingFixedEpochEndTime() external view returns (uint256);
    function stakingEpochStartTime() external view returns (uint256);
    function stakingEpochStartBlock() external view returns (uint256);
    function restake(
        address _poolStakingAddress,
        uint256 validatorReward
    ) external payable;
    function snapshotPoolStakeAmounts(
        uint256 _epoch,
        address _stakingPool
    ) external;
    function getPoolValidatorStakeAmount(
        uint256 _epoch,
        address _stakingPool
    ) external view returns (uint256);
}

// SPDX-License-Identifier: Apache 2.0
pragma solidity =0.8.25;
interface IValidatorSetHbbft {
    struct ValidatorSetParams {
        address blockRewardContract;
        address randomContract;
        address stakingContract;
        address keyGenHistoryContract;
        address bonusScoreContract;
        address connectivityTrackerContract;
        uint256 validatorInactivityThreshold;
    }
    // Key Generation states of validator.
    enum KeyGenMode {
        NotAPendingValidator,
        WritePart,
        WaitForOtherParts,
        WriteAck,
        WaitForOtherAcks,
        AllKeysDone
    }
    function announceAvailability(uint256, bytes32) external;
    function finalizeChange() external;
    function newValidatorSet() external;
    function setStakingAddress(address, address) external;
    function handleFailedKeyGeneration() external;
    function isFullHealth() external view returns (bool);
    function blockRewardContract() external view returns (address);
    function canCallAnnounceAvailability(address _miningAddress)
        external
        view
        returns (bool);
    function getPendingValidators() external view returns (address[] memory);
    function getPreviousValidators() external view returns (address[] memory);
    function getValidators() external view returns (address[] memory);
    function isValidator(address) external view returns (bool);
    function isValidatorOrPending(address) external view returns (bool);
    function isPendingValidator(address) external view returns (bool);
    function getPendingValidatorKeyGenerationMode(address)
        external
        view
        returns (KeyGenMode);
    function maxValidators() external view returns (uint256);
    function miningByStakingAddress(address) external view returns (address);
    function randomContract() external view returns (address);
    function notifyUnavailability(address) external;
    function stakingByMiningAddress(address) external view returns (address);
    function publicKeyByStakingAddress(address)
        external
        view
        returns (bytes memory);
    function getPublicKey(address) external view returns (bytes memory);
    function getStakingContract() external view returns (address);
    function validatorAvailableSince(address) external view returns (uint256);
    function isValidatorAbandoned(address) external view returns (bool);
    function getValidatorCountSweetSpot(uint256)
        external
        view
        returns (uint256);
    function getCurrentValidatorsCount() external view returns (uint256);
}

// SPDX-License-Identifier: Apache 2.0
pragma solidity =0.8.25;
error Unauthorized();
error ValidatorsListEmpty();
error ZeroAddress();
error ZeroGasPrice();

// SPDX-License-Identifier: Apache 2.0
pragma solidity =0.8.25;
import { OwnableUpgradeable } from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
abstract contract ValueGuards is OwnableUpgradeable {
    // =============================================== Storage ========================================================
    /**
     * @dev Represents a parameter range for a specific getter function.
     * @param getter The getter function signature.
     * @param range The range of values for the parameter.
     */
    struct ParameterRange {
        bytes4 getter;
        uint256[] range;
    }
    struct ValueGuardsStorage {
        /**
        * @dev A mapping that stores the allowed parameter ranges for each function signature.
        */
        mapping(bytes4 => ParameterRange) allowedParameterRange;
    }
    bytes32 private constant VALUEGUARDS_STORAGE_NAMESPACE = keccak256(abi.encode(uint256(keccak256("valueguards.storage")) - 1)) & ~bytes32(uint256(0xff));
    function _getValueGuardsStorage() private pure returns (ValueGuardsStorage storage $) {
        bytes32 slot = VALUEGUARDS_STORAGE_NAMESPACE;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            $.slot := slot
        }
    }
    // ============================================== Events ==========================================================
    /**
     * @dev Event emitted when changeable parameters are set.
     * @param setter Setter function signature.
     * @param getter Getter function signature.
     * @param params An array of uint256 values representing the parameters.
     */
    event SetChangeableParameter(bytes4 setter, bytes4 getter, uint256[] params);
    /**
     * @dev Emitted when changeable parameters are removed.
     * @param funcSelector The function selector of the removed changeable parameters.
     */
    event RemoveChangeableParameter(bytes4 funcSelector);
    // ============================================== Errors ==========================================================
    error NewValueOutOfRange(uint256 _newVal);
    error GetterCallFailed();
    // ============================================== Modifiers =======================================================
    /**
     * @dev Modifier to check if a new value is within the allowed range.
     * @param newVal The new value to be checked.
     * @notice This modifier is used to ensure that the new value is within the allowed range.
     * If the new value is not within the allowed range, the function using this modifier
     * will revert with an error message.
     */
    modifier withinAllowedRange(uint256 newVal) {
        if (!isWithinAllowedRange(msg.sig, newVal)) {
            revert NewValueOutOfRange(newVal);
        }
        _;
    }
    // =============================================== Initializers ====================================================
    /**
     * @dev Inits the allowed changeable parameter for a specific setter function.
     * @param setter Setter function selector.
     * @param getter Getter function selector.
     * @param params The array of allowed parameter values.
     */
    function __initAllowedChangeableParameter(
        bytes4 setter,
        bytes4 getter,
        uint256[] memory params
    ) internal onlyInitializing {
        ValueGuardsStorage storage $ = _getValueGuardsStorage();
        $.allowedParameterRange[setter] = ParameterRange({ getter: getter, range: params });
        emit SetChangeableParameter(setter, getter, params);
    }
    // =============================================== Setters ========================================================
    /**
     * @dev Sets the allowed changeable parameter for a specific setter function.
     * @param setter Setter function selector.
     * @param getter Getter function selector.
     * @param params The array of allowed parameter values.
     */
    function setAllowedChangeableParameter(bytes4 setter, bytes4 getter, uint256[] calldata params) public onlyOwner {
        ValueGuardsStorage storage $ = _getValueGuardsStorage();
        $.allowedParameterRange[setter] = ParameterRange({ getter: getter, range: params });
        emit SetChangeableParameter(setter, getter, params);
    }
    /**
     * @dev Removes the allowed changeable parameter for a given function selector.
     * @param funcSelector The function selector for which the allowed changeable parameter should be removed.
     */
    function removeAllowedChangeableParameter(bytes4 funcSelector) public onlyOwner {
        ValueGuardsStorage storage $ = _getValueGuardsStorage();
        delete $.allowedParameterRange[funcSelector];
        emit RemoveChangeableParameter(funcSelector);
    }
    // =============================================== Getters ========================================================
    /**
     * @dev Checks if the given `newVal` is within the allowed range for the specified function selector.
     * @param funcSelector The function selector.
     * @param newVal The new value to be checked.
     * @return A boolean indicating whether the `newVal` is within the allowed range.
     */
    function isWithinAllowedRange(bytes4 funcSelector, uint256 newVal) public view returns (bool) {
        ValueGuardsStorage storage $ = _getValueGuardsStorage();
        ParameterRange memory allowedRange = $.allowedParameterRange[funcSelector];
        if (allowedRange.range.length == 0) {
            return false;
        }
        uint256[] memory range = allowedRange.range;
        uint256 currVal = _getValueWithSelector(allowedRange.getter);
        for (uint256 i = 0; i < range.length; i++) {
            if (range[i] == currVal) {
                uint256 leftVal = (i > 0) ? range[i - 1] : range[0];
                uint256 rightVal = (i < range.length - 1) ? range[i + 1] : range[range.length - 1];
                return !(newVal != leftVal && newVal != rightVal);
            }
        }
        return false;
    }
    function getAllowedParamsRange(string memory _selector) external view returns (ParameterRange memory) {
        return _getValueGuardsStorage().allowedParameterRange[bytes4(keccak256(bytes(_selector)))];
    }
    function getAllowedParamsRangeWithSelector(bytes4 _selector) external view returns (ParameterRange memory) {
        return _getValueGuardsStorage().allowedParameterRange[_selector];
    }
    // =============================================== Internal ========================================================
    /**
     * @dev Internal function to get the value of a contract state variable using a getter function.
     * @param getterSelector The selector of the getter function.
     * @return The value of the contract state variable.
     */
    function _getValueWithSelector(bytes4 getterSelector) private view returns (uint256) {
        bytes memory payload = abi.encodeWithSelector(getterSelector);
        (bool success, bytes memory result) = address(this).staticcall(payload);
        if (!success) {
            revert GetterCallFailed();
        }
        return abi.decode(result, (uint256));
    }
}

[{"type":"constructor","stateMutability":"nonpayable","inputs":[]},{"type":"error","name":"AlreadyReported","inputs":[{"type":"address","name":"reporter","internalType":"address"},{"type":"address","name":"validator","internalType":"address"}]},{"type":"error","name":"CannotReportByFlaggedValidator","inputs":[{"type":"address","name":"reporter","internalType":"address"}]},{"type":"error","name":"EpochPenaltiesAlreadySent","inputs":[{"type":"uint256","name":"epoch","internalType":"uint256"}]},{"type":"error","name":"GetterCallFailed","inputs":[]},{"type":"error","name":"InvalidBlock","inputs":[]},{"type":"error","name":"InvalidInitialization","inputs":[]},{"type":"error","name":"NewValueOutOfRange","inputs":[{"type":"uint256","name":"_newVal","internalType":"uint256"}]},{"type":"error","name":"NotInitializing","inputs":[]},{"type":"error","name":"OnlyValidator","inputs":[]},{"type":"error","name":"OwnableInvalidOwner","inputs":[{"type":"address","name":"owner","internalType":"address"}]},{"type":"error","name":"OwnableUnauthorizedAccount","inputs":[{"type":"address","name":"account","internalType":"address"}]},{"type":"error","name":"ReportTooEarly","inputs":[]},{"type":"error","name":"Unauthorized","inputs":[]},{"type":"error","name":"UnknownReconnectReporter","inputs":[{"type":"address","name":"reporter","internalType":"address"},{"type":"address","name":"validator","internalType":"address"}]},{"type":"error","name":"ZeroAddress","inputs":[]},{"type":"event","name":"Initialized","inputs":[{"type":"uint64","name":"version","internalType":"uint64","indexed":false}],"anonymous":false},{"type":"event","name":"NotifyEarlyEpochEnd","inputs":[{"type":"uint256","name":"epoch","internalType":"uint256","indexed":true},{"type":"uint256","name":"blockNumber","internalType":"uint256","indexed":true}],"anonymous":false},{"type":"event","name":"OwnershipTransferred","inputs":[{"type":"address","name":"previousOwner","internalType":"address","indexed":true},{"type":"address","name":"newOwner","internalType":"address","indexed":true}],"anonymous":false},{"type":"event","name":"RemoveChangeableParameter","inputs":[{"type":"bytes4","name":"funcSelector","internalType":"bytes4","indexed":false}],"anonymous":false},{"type":"event","name":"ReportMissingConnectivity","inputs":[{"type":"address","name":"reporter","internalType":"address","indexed":true},{"type":"address","name":"validator","internalType":"address","indexed":true},{"type":"uint256","name":"blockNumber","internalType":"uint256","indexed":true}],"anonymous":false},{"type":"event","name":"ReportReconnect","inputs":[{"type":"address","name":"reporter","internalType":"address","indexed":true},{"type":"address","name":"validator","internalType":"address","indexed":true},{"type":"uint256","name":"blockNumber","internalType":"uint256","indexed":true}],"anonymous":false},{"type":"event","name":"SetChangeableParameter","inputs":[{"type":"bytes4","name":"setter","internalType":"bytes4","indexed":false},{"type":"bytes4","name":"getter","internalType":"bytes4","indexed":false},{"type":"uint256[]","name":"params","internalType":"uint256[]","indexed":false}],"anonymous":false},{"type":"event","name":"SetReportDisallowPeriod","inputs":[{"type":"uint256","name":"_reportDisallowPeriodSeconds","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"contract IBlockRewardHbbft"}],"name":"blockRewardContract","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"contract IBonusScoreSystem"}],"name":"bonusScoreContract","inputs":[]},{"type":"function","stateMutability":"view","outputs":[],"name":"checkReportMissingConnectivityCallable","inputs":[{"type":"address","name":"caller","internalType":"address"},{"type":"address","name":"validator","internalType":"address"},{"type":"uint256","name":"blockNumber","internalType":"uint256"},{"type":"bytes32","name":"blockHash","internalType":"bytes32"}]},{"type":"function","stateMutability":"view","outputs":[],"name":"checkReportReconnectCallable","inputs":[{"type":"address","name":"caller","internalType":"address"},{"type":"address","name":"validator","internalType":"address"},{"type":"uint256","name":"blockNumber","internalType":"uint256"},{"type":"bytes32","name":"blockHash","internalType":"bytes32"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"countFaultyValidators","inputs":[{"type":"uint256","name":"epoch","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"currentEpoch","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"earlyEpochEndThreshold","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"earlyEpochEndToleranceLevel","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"tuple","name":"","internalType":"struct ValueGuards.ParameterRange","components":[{"type":"bytes4","name":"getter","internalType":"bytes4"},{"type":"uint256[]","name":"range","internalType":"uint256[]"}]}],"name":"getAllowedParamsRange","inputs":[{"type":"string","name":"_selector","internalType":"string"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"tuple","name":"","internalType":"struct ValueGuards.ParameterRange","components":[{"type":"bytes4","name":"getter","internalType":"bytes4"},{"type":"uint256[]","name":"range","internalType":"uint256[]"}]}],"name":"getAllowedParamsRangeWithSelector","inputs":[{"type":"bytes4","name":"_selector","internalType":"bytes4"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"address[]","name":"","internalType":"address[]"}],"name":"getFlaggedValidators","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"address[]","name":"","internalType":"address[]"}],"name":"getFlaggedValidatorsByEpoch","inputs":[{"type":"uint256","name":"epoch","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getFlaggedValidatorsCount","inputs":[{"type":"uint256","name":"epoch","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getValidatorConnectivityScore","inputs":[{"type":"uint256","name":"epoch","internalType":"uint256"},{"type":"address","name":"validator","internalType":"address"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"initialize","inputs":[{"type":"address","name":"_contractOwner","internalType":"address"},{"type":"address","name":"_validatorSetContract","internalType":"address"},{"type":"address","name":"_stakingContract","internalType":"address"},{"type":"address","name":"_blockRewardContract","internalType":"address"},{"type":"address","name":"_bonusScoreContract","internalType":"address"},{"type":"uint256","name":"_reportDisallowPeriodSeconds","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"isEarlyEpochEnd","inputs":[{"type":"uint256","name":"","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"isFaultyValidator","inputs":[{"type":"uint256","name":"epoch","internalType":"uint256"},{"type":"address","name":"validator","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"isReported","inputs":[{"type":"uint256","name":"","internalType":"uint256"},{"type":"address","name":"validator","internalType":"address"},{"type":"address","name":"reporter","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"isWithinAllowedRange","inputs":[{"type":"bytes4","name":"funcSelector","internalType":"bytes4"},{"type":"uint256","name":"newVal","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address"}],"name":"owner","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"penaliseFaultyValidators","inputs":[{"type":"uint256","name":"epoch","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"removeAllowedChangeableParameter","inputs":[{"type":"bytes4","name":"funcSelector","internalType":"bytes4"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"renounceOwnership","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"reportDisallowPeriod","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"reportMissingConnectivity","inputs":[{"type":"address","name":"validator","internalType":"address"},{"type":"uint256","name":"blockNumber","internalType":"uint256"},{"type":"bytes32","name":"blockHash","internalType":"bytes32"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"reportReconnect","inputs":[{"type":"address","name":"validator","internalType":"address"},{"type":"uint256","name":"blockNumber","internalType":"uint256"},{"type":"bytes32","name":"blockHash","internalType":"bytes32"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"setAllowedChangeableParameter","inputs":[{"type":"bytes4","name":"setter","internalType":"bytes4"},{"type":"bytes4","name":"getter","internalType":"bytes4"},{"type":"uint256[]","name":"params","internalType":"uint256[]"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"setReportDisallowPeriod","inputs":[{"type":"uint256","name":"_reportDisallowPeriodSeconds","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"contract IStakingHbbft"}],"name":"stakingContract","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"transferOwnership","inputs":[{"type":"address","name":"newOwner","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"contract IValidatorSetHbbft"}],"name":"validatorSetContract","inputs":[]}]