refactor code

web3/src/contracts/LayerTwo.sol

+//SPDX-License-Identifier: Unlicense
+pragma solidity ^0.8.0;
+pragma experimental ABIEncoderV2;
+
+contract LayerTwo {
+    uint256 cluster_size = 5; // TODO func change_cluster_size
+
+    enum Status {
+        enable,
+        forming,
+        disable
+    }
+
+    enum ValStatus {
+        inCluster, // running
+        excluded,
+        removed,
+        ready
+    }
+
+    struct ValidatorInfo {
+        address valAddress;
+        bytes32 uri;
+        uint256 stake;
+        bytes publicKey; // публичный ключ, которы используется на L2, L3, address недостаточен для этого
+        uint256 cluster;
+        uint256 start_time_in_cluster;
+        ValStatus status;
+    }
+
+    mapping(address => uint256) public valIndexInArray;
+    ValidatorInfo[] public validatorInfo;
+
+    struct ClusterInfo {
+        address[] vals;
+        address leader;
+        Status status;
+        uint256 start_time;
+        // uint256 totalStakes;
+    }
+
+    // mapping(uint256 => uint256) clusterIndexInArray;
+    ClusterInfo[] clusterInfo;
+
+    struct Commit {
+        address sender;
+        bytes32 commit;
+    }
+    mapping(uint256 => Commit[]) rollupCommits;
+
+    event NewL2NodeAdded(address validator, bytes32 uri);
+    event NewL2ClusterSetted(address leader, ClusterInfo cluster_info);
+    event ValidatorRegistedInCluster(address validator, uint256 cluster_num);
+    event ClusterUpdated(
+        uint256 cluster_num,
+        address val_out,
+        uint256 end_time,
+        address val_in,
+        uint256 start_time
+    );
+    event ValidatorRemovedFromRegistry(address validator);
+    event ValidatorRemovedFromCluster(
+        uint256 cluster_num,
+        address validator_out,
+        uint256 end_time,
+        address validator_in,
+        uint256 start_time
+    );
+    event ValidatorAddedToCluster(
+        uint256 cluster_num,
+        address val,
+        uint256 start_time
+    );
+
+    // добавить pub_key в аргементы
+    function addToRegistry(bytes32 _uri) public payable {
+        // TODO: проверка, что такого адреса нет в реестре
+        // TODO: адрес не нулевой
+        // TODO: stake соотвествует размеру задаваемому программно
+        // TODO: uri не пусто
+
+        ValidatorInfo memory val;
+
+        val.uri = _uri;
+        val.stake = msg.value; // на будущее - вместо ETH использовать ERC20
+        val.status = ValStatus.ready;
+        // validatorInfo[msg.sender] = val;
+        validatorInfo.push(val);
+
+        // mint Note or DM
+
+        // если количество валидаторов ~ 3 создать кластер
+        if (validatorInfo.length > 3) {
+            address[] memory vals;
+
+            for (uint256 i = 0; i < validatorInfo.length; i++) {
+                vals[i] = validatorInfo[i].valAddress;
+            }
+
+            setNewL2Cluster(vals);
+        }
+
+        emit NewL2NodeAdded(msg.sender, _uri);
+    }
+
+    function removeFromRegistry() public {
+        delete validatorInfo[valIndexInArray[msg.sender]];
+        delete valIndexInArray[msg.sender];
+
+        // TODO: вернуть stake
+
+        emit ValidatorRemovedFromRegistry(msg.sender);
+    }
+
+    function addToCluster(uint256 cluster_num, address val) public {
+        require(
+            getValStatus(val) == ValStatus.ready,
+            "Validator doesn ready for work"
+        );
+
+        ClusterInfo storage cluster = clusterInfo[cluster_num];
+        cluster.vals.push(val);
+
+        validatorInfo[valIndexInArray[val]].cluster = cluster_num;
+        validatorInfo[valIndexInArray[val]].status = ValStatus.inCluster;
+
+        emit ValidatorAddedToCluster(cluster_num, val, block.timestamp);
+    }
+
+    function kick() private {}
+
+    function removeFromCluster(uint256 cluster_num) public {
+        // require(validatorInfo.length > 1, "ERROR: last validator cannot be deleted");
+        // require(validatorInfo[msg.sender] != 0, "ERROR: wrong validator");
+        ClusterInfo memory cluster = clusterInfo[cluster_num];
+
+        address val_in = getNextVal(valIndexInArray[msg.sender]);
+
+        validatorInfo[valIndexInArray[msg.sender]].cluster = 0;
+        validatorInfo[valIndexInArray[msg.sender]].status = ValStatus.removed;
+
+        for (uint256 i = 0; i < cluster.vals.length; i++) {
+            if (cluster.vals[i] == msg.sender) {
+                delete cluster.vals[i];
+            }
+        }
+
+        addToCluster(cluster_num, val_in);
+
+        // TODO: вернуть stake исключаемому валидатору
+
+        emit ValidatorRemovedFromCluster(
+            cluster_num,
+            msg.sender,
+            block.timestamp, // во время endtime валидтор может быть должны сделать коммит
+            val_in,
+            block.timestamp
+        );
+    }
+
+    function setNewL2Cluster(address[] memory _vals) public {
+        // TODO проверка, что такие адреса являются валидаторами
+        // TODO проверка, что участники не вхоят в другие кластеры
+        // TODO проверка что вызывающий является валидатором
+        // TODO проверка достаточно стейка для участия валидатора
+
+        ClusterInfo memory cluster;
+        uint256 cluster_num = clusterInfo.length + 1;
+
+        for (uint256 i = 0; i < _vals.length; i++) {
+            cluster.vals[i] = _vals[i];
+
+            validatorInfo[i].cluster = cluster_num;
+        }
+
+        cluster.status = Status.enable;
+        // cluster.totalStakes = 0;
+
+        clusterInfo.push(cluster);
+        clusterInfo[cluster_num] = cluster;
+        emit NewL2ClusterSetted(msg.sender, cluster); // обновить поля события
+    }
+
+    function setCommit(uint256 rollup, bytes32 _commit) public {
+        // TODO: проверка, что такого комита ещё не сделал этот валидтор
+        Commit memory cm;
+
+        cm.sender = msg.sender;
+        cm.commit = _commit;
+
+        rollupCommits[rollup].push(cm);
+    }
+
+    // function registerInCluster(uint256 cluster_num) public payable {
+    //     // TODO: проверка, что адрес является валидатором
+    //     // TODO: проверка, что адрес заявлен в кластере
+    //     // TODO: проверка, что кластер существует
+    //     // TODO: провкра, что stake хватает
+    //     validatorInfo[msg.sender].cluster = cluster_num;
+    //     // TODO: списать stake со структуры Validator на структуру ClusterInfo?
+    //     // TODO: проверка, что все зарегистрированы,
+    //     // если зарегистрированы все, то статус кластера меняется, вызов события перехода статуса кластера в Enable
+    //     emit ValidatorRegistedInCluster(msg.sender, cluster_num);
+    // }
+
+    // function getActualCluster(uint256 index)
+    //     internal
+    //     view
+    //     returns (bytes32[] memory)
+    // {
+    //     // TODO: проверка, что в кластер зарегались все валидаторы
+    //     uint256 addressCount = clusters[index].vals.length;
+    //     address[] memory actual_vals = new address[](addressCount);
+    //     uint256 valCount;
+    //     for (uint256 a = 0; a < clusters[index].vals.length; a++) {
+    //         actual_vals[a] = clusters[index].vals[a];
+    //         valCount++;
+    //     }
+    //     bytes32[] memory uris = new bytes32[](valCount);
+    //     for (uint256 b = 0; b < actual_vals.length; b++) {
+    //         bytes32 uri = validatorInfo[actual_vals[b]].uri;
+    //         uris[b] = uri;
+    //     }
+    //     return uris;
+    // }
+
+    function getValidatorInfo(address val)
+        public
+        view
+        returns (ValidatorInfo memory)
+    {
+        return validatorInfo[valIndexInArray[val]];
+    }
+
+    function getNextVal(uint256 valOutIndex) public view returns (address) {
+        // TODO: начинать с индекса удаляемого валидатора
+        for (uint256 i = valOutIndex; i < validatorInfo.length; i++) {
+            if (validatorInfo[i].status == ValStatus.ready) {
+                return validatorInfo[i].valAddress;
+            }
+        }
+
+        return address(0);
+    }
+
+    function getValStatus(address val) public view returns (ValStatus) {
+        return validatorInfo[valIndexInArray[val]].status;
+    }
+
+    function isL2N(address addr) public view returns (bool res) {
+        if (valIndexInArray[addr] > 0) return true;
+        else return false;
+    }
+
+    function openChallangeForL2N() public {
+        // WiP
+    }
+
+    function updateStake() public payable {
+        validatorInfo[valIndexInArray[msg.sender]].stake += msg.value;
+    }
+
+    function change_cluster_size(uint256 size) public {
+        cluster_size = size;
+    }
+}

web3/src/contracts/art/LayerTwo.sol/LayerTwo.dbg.json

+{
+  "_format": "hh-sol-dbg-1",
+  "buildInfo": "../../build-info/c5a9010f48daf344cedd8ee5967b49dc.json"
+}