Contract Address Details

// SPDX-License-Identifier: Apache 2.0
pragma solidity =0.8.25;
import { Initializable } from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import { OwnableUpgradeable } from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import { IKeyGenHistory } from "./interfaces/IKeyGenHistory.sol";
import { IValidatorSetHbbft } from "./interfaces/IValidatorSetHbbft.sol";
import { IStakingHbbft } from "./interfaces/IStakingHbbft.sol";
import { Unauthorized, ValidatorsListEmpty, ZeroAddress } from "./lib/Errors.sol";
contract KeyGenHistory is Initializable, OwnableUpgradeable, IKeyGenHistory {
    // =============================================== Storage ========================================================
    // WARNING: since this contract is upgradeable, do not remove
    // existing storage variables and do not change their types!
    address[] public validatorSet;
    mapping(address => bytes) public parts;
    mapping(address => bytes[]) public acks;
    /// @dev number of parts written in this key generation round.
    uint128 public numberOfPartsWritten;
    /// @dev number of full ack sets written in this key generation round.
    uint128 public numberOfAcksWritten;
    /// @dev The address of the `ValidatorSetHbbft` contract.
    IValidatorSetHbbft public validatorSetContract;
    /// @dev round counter for key generation rounds.
    /// in an ideal world, every key generation only requires one try,
    /// and all validators manage to write their acks and parts,
    /// so it is possible to achieve this goal in round 0.
    /// in the real world, there are failures,
    /// this mechanics helps covering that,
    /// by revoking transactions, that were targeted for an earlier key gen round.
    /// more infos: https://github.com/DMDcoin/hbbft-posdao-contracts/issues/106
    uint256 public currentKeyGenRound;
    error AcksAlreadySubmitted();
    error IncorrectEpoch();
    error IncorrectRound(uint256 expected, uint256 submited);
    error NotPendingValidator(address validator);
    error PartsAlreadySubmitted();
    error WrongEpoch();
    error WrongAcksNumber();
    error WrongPartsNumber();
    /// @dev Ensures the caller is ValidatorSet contract.
    modifier onlyValidatorSet() {
        if (msg.sender != address(validatorSetContract)) {
            revert Unauthorized();
        }
        _;
    }
    /// @dev ensures that Key Generation functions are called with wrong _epoch
    /// parameter to prevent old and wrong transactions get picked up.
    modifier onlyUpcommingEpoch(uint256 _epoch) {
        if (IStakingHbbft(validatorSetContract.getStakingContract()).stakingEpoch() + 1 != _epoch) {
            revert IncorrectEpoch();
        }
        _;
    }
    /// @dev ensures that Key Generation functions are called with wrong _epoch
    /// parameter to prevent old and wrong transactions get picked up.
    modifier onlyCorrectRound(uint256 _roundCounter) {
        if (currentKeyGenRound != _roundCounter) {
            revert IncorrectRound(currentKeyGenRound, _roundCounter);
        }
        _;
    }
    /// @custom:oz-upgrades-unsafe-allow constructor
    constructor() {
        // Prevents initialization of implementation contract
        _disableInitializers();
    }
    function initialize(
        address _contractOwner,
        address _validatorSetContract,
        address[] memory _validators,
        bytes[] memory _parts,
        bytes[][] memory _acks
    ) external initializer {
        if (_contractOwner == address(0) || _validatorSetContract == address(0)) {
            revert ZeroAddress();
        }
        if (_validators.length == 0) {
            revert ValidatorsListEmpty();
        }
        if (_validators.length != _parts.length) {
            revert WrongPartsNumber();
        }
        if (_validators.length != _acks.length) {
            revert WrongAcksNumber();
        }
        __Ownable_init(_contractOwner);
        validatorSetContract = IValidatorSetHbbft(_validatorSetContract);
        for (uint256 i = 0; i < _validators.length; i++) {
            parts[_validators[i]] = _parts[i];
            acks[_validators[i]] = _acks[i];
        }
        currentKeyGenRound = 1;
    }
    /// @dev Clears the state (acks and parts of previous validators.
    /// @param _prevValidators The list of previous validators.
    function clearPrevKeyGenState(address[] calldata _prevValidators) external onlyValidatorSet {
        for (uint256 i = 0; i < _prevValidators.length; ++i) {
            delete parts[_prevValidators[i]];
            delete acks[_prevValidators[i]];
        }
        numberOfPartsWritten = 0;
        numberOfAcksWritten = 0;
    }
    function notifyKeyGenFailed() external onlyValidatorSet {
        currentKeyGenRound = currentKeyGenRound + 1;
    }
    function notifyNewEpoch() external onlyValidatorSet {
        currentKeyGenRound = 1;
    }
    function writePart(
        uint256 _upcommingEpoch,
        uint256 _roundCounter,
        bytes memory _part
    ) external onlyUpcommingEpoch(_upcommingEpoch) onlyCorrectRound(_roundCounter) {
        // It can only be called by a new validator which is elected but not yet finalized...
        // ...or by a validator which is already in the validator set.
        if (!validatorSetContract.isPendingValidator(msg.sender)) {
            revert NotPendingValidator(msg.sender);
        }
        if (parts[msg.sender].length != 0) {
            revert PartsAlreadySubmitted();
        }
        parts[msg.sender] = _part;
        numberOfPartsWritten++;
    }
    function writeAcks(
        uint256 _upcommingEpoch,
        uint256 _roundCounter,
        bytes[] memory _acks
    ) external onlyUpcommingEpoch(_upcommingEpoch) onlyCorrectRound(_roundCounter) {
        // It can only be called by a new validator which is elected but not yet finalized...
        // ...or by a validator which is already in the validator set.
        if (!validatorSetContract.isPendingValidator(msg.sender)) {
            revert NotPendingValidator(msg.sender);
        }
        if (acks[msg.sender].length != 0) {
            revert AcksAlreadySubmitted();
        }
        acks[msg.sender] = _acks;
        numberOfAcksWritten++;
    }
    function getPart(address _val) external view returns (bytes memory) {
        return parts[_val];
    }
    function getAcksLength(address val) external view returns (uint256) {
        return acks[val].length;
    }
    function getCurrentKeyGenRound() external view returns (uint256) {
        return currentKeyGenRound;
    }
    function getNumberOfKeyFragmentsWritten() external view returns (uint128, uint128) {
        return (numberOfPartsWritten, numberOfAcksWritten);
    }
}

// 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: Apache 2.0
pragma solidity =0.8.25;
interface IKeyGenHistory {
    function clearPrevKeyGenState(address[] calldata) external;
    function getAcksLength(address val) external view returns (uint256);
    function getPart(address val) external view returns (bytes memory);
    function getCurrentKeyGenRound() external view returns (uint256);
    function getNumberOfKeyFragmentsWritten()
        external
        view
        returns (uint128, uint128);
    function notifyNewEpoch() external;
    function notifyKeyGenFailed() 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();

[{"type":"constructor","stateMutability":"nonpayable","inputs":[]},{"type":"error","name":"AcksAlreadySubmitted","inputs":[]},{"type":"error","name":"IncorrectEpoch","inputs":[]},{"type":"error","name":"IncorrectRound","inputs":[{"type":"uint256","name":"expected","internalType":"uint256"},{"type":"uint256","name":"submited","internalType":"uint256"}]},{"type":"error","name":"InvalidInitialization","inputs":[]},{"type":"error","name":"NotInitializing","inputs":[]},{"type":"error","name":"NotPendingValidator","inputs":[{"type":"address","name":"validator","internalType":"address"}]},{"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":"PartsAlreadySubmitted","inputs":[]},{"type":"error","name":"Unauthorized","inputs":[]},{"type":"error","name":"ValidatorsListEmpty","inputs":[]},{"type":"error","name":"WrongAcksNumber","inputs":[]},{"type":"error","name":"WrongEpoch","inputs":[]},{"type":"error","name":"WrongPartsNumber","inputs":[]},{"type":"error","name":"ZeroAddress","inputs":[]},{"type":"event","name":"Initialized","inputs":[{"type":"uint64","name":"version","internalType":"uint64","indexed":false}],"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":"function","stateMutability":"view","outputs":[{"type":"bytes","name":"","internalType":"bytes"}],"name":"acks","inputs":[{"type":"address","name":"","internalType":"address"},{"type":"uint256","name":"","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"clearPrevKeyGenState","inputs":[{"type":"address[]","name":"_prevValidators","internalType":"address[]"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"currentKeyGenRound","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getAcksLength","inputs":[{"type":"address","name":"val","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getCurrentKeyGenRound","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint128","name":"","internalType":"uint128"},{"type":"uint128","name":"","internalType":"uint128"}],"name":"getNumberOfKeyFragmentsWritten","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"bytes","name":"","internalType":"bytes"}],"name":"getPart","inputs":[{"type":"address","name":"_val","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":"_validators","internalType":"address[]"},{"type":"bytes[]","name":"_parts","internalType":"bytes[]"},{"type":"bytes[][]","name":"_acks","internalType":"bytes[][]"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"notifyKeyGenFailed","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"notifyNewEpoch","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint128","name":"","internalType":"uint128"}],"name":"numberOfAcksWritten","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint128","name":"","internalType":"uint128"}],"name":"numberOfPartsWritten","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address"}],"name":"owner","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"bytes","name":"","internalType":"bytes"}],"name":"parts","inputs":[{"type":"address","name":"","internalType":"address"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"renounceOwnership","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"transferOwnership","inputs":[{"type":"address","name":"newOwner","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address"}],"name":"validatorSet","inputs":[{"type":"uint256","name":"","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"contract IValidatorSetHbbft"}],"name":"validatorSetContract","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"writeAcks","inputs":[{"type":"uint256","name":"_upcommingEpoch","internalType":"uint256"},{"type":"uint256","name":"_roundCounter","internalType":"uint256"},{"type":"bytes[]","name":"_acks","internalType":"bytes[]"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"writePart","inputs":[{"type":"uint256","name":"_upcommingEpoch","internalType":"uint256"},{"type":"uint256","name":"_roundCounter","internalType":"uint256"},{"type":"bytes","name":"_part","internalType":"bytes"}]}]