Merge pull request #749 from lidofinance/feat/revert-5.2-5.3

Feat: Revert 5.2 and 5.3

Author: F4ever

README.md

@@ -203,13 +203,6 @@ In manual mode all sleeps are disabled and `ALLOW_REPORTING_IN_BUNKER_MODE` is T
 | `CSM_ORACLE_MAX_CONCURRENCY`                           | Max count of dedicated workers for CSM module                                                                                                                            | False    | `2`                                     |
 | `CACHE_PATH`                                           | Directory to store cache for CSM module                                                                                                                                  | False    | `.`                                     |
 
-### Using bundling with private relays
-| Name                           | Description                        | Example value                 |
-|--------------------------------|------------------------------------|-------------------------------|
-| `PRIVATE_RELAYS_LIST`          | List of private relays RPC         | `http://relay1,http://relay2` |
-| `BUNDLE_GAS_LIMIT_FOR_EACH_TX` | Gas limit for bundled transactions | `7000000`                     |
-| `BUNDLE_TIMEOUT_SECONDS`       | Bundling timeout                   | `1368`                        |
-
 ### Mainnet variables
 > LIDO_LOCATOR_ADDRESS=0xC1d0b3DE6792Bf6b4b37EccdcC24e45978Cfd2Eb
 > ALLOW_REPORTING_IN_BUNKER_MODE=False

assets/NodeOperatorRegistry.json

@@ -43,9 +43,6 @@
 SHARE_RATE_PRECISION_E27 = 10**27
 TOTAL_BASIS_POINTS = 10000
 
-# Staking modules inherited from NOR that support reward distribution
-CURATED_MODULE_TYPE = b'curated-onchain-v1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-
 # Local constants
 GWEI_TO_WEI = 10**9
 MAX_BLOCK_GAS_LIMIT = 30_000_000

src/constants.py

@@ -1,16 +1,13 @@
 import logging
 from collections import defaultdict
-from datetime import datetime
 from time import sleep
-from typing import cast
 
-from eth_typing import ChecksumAddress
 from hexbytes import HexBytes
 from web3.exceptions import ContractCustomError
 from web3.types import Wei
 
 from src import variables
-from src.constants import SHARE_RATE_PRECISION_E27, CURATED_MODULE_TYPE
+from src.constants import SHARE_RATE_PRECISION_E27
 from src.modules.accounting.third_phase.extra_data import ExtraDataService
 from src.modules.accounting.third_phase.types import ExtraData, FormatList
 from src.modules.accounting.types import (
@@ -34,7 +31,6 @@
 from src.metrics.prometheus.duration_meter import duration_meter
 from src.modules.submodules.types import ZERO_HASH
 from src.providers.execution.contracts.accounting_oracle import AccountingOracleContract
-from src.providers.execution.contracts.staking_module import NodeOperatorRegistry
 from src.services.validator_state import LidoValidatorStateService
 from src.modules.submodules.consensus import ConsensusModule, InitialEpochIsYetToArriveRevert
 from src.modules.submodules.oracle_module import BaseModule, ModuleExecuteDelay
@@ -44,7 +40,6 @@
 from src.utils.cache import global_lru_cache as lru_cache
 from src.utils.units import gwei_to_wei
 from src.variables import ALLOW_REPORTING_IN_BUNKER_MODE
-from src.web3py.extensions.tx_bundle import TransactionBundle
 from src.web3py.types import Web3
 from src.web3py.extensions.lido_validators import StakingModule
 
@@ -302,9 +297,8 @@ def simulate_rebase_after_report(
         )
 
     def get_shares_to_burn(self, blockstamp: ReferenceBlockStamp) -> int:
-        # shares_data = self.w3.lido_contracts.burner.get_shares_requested_to_burn(blockstamp.block_hash)
-        # return shares_data.cover_shares + shares_data.non_cover_shares
-        return 0
+        shares_data = self.w3.lido_contracts.burner.get_shares_requested_to_burn(blockstamp.block_hash)
+        return shares_data.cover_shares + shares_data.non_cover_shares
 
     def _get_slots_elapsed_from_last_report(self, blockstamp: ReferenceBlockStamp):
         chain_conf = self.get_chain_config(blockstamp)
@@ -415,51 +409,3 @@ def _combine_report_parts(
             extra_data_hash=extra_data.data_hash,
             extra_data_items_count=extra_data.items_count,
         )
-
-
-    # --- TX bundling ---
-    @staticmethod
-    def _use_private_relays(blockstamp: ReferenceBlockStamp) -> bool:
-        # If BUNDLE_SEND_TIMEOUT seconds have passed since the reference slot was validated, use the classic flow to send the transaction.
-        return bool(variables.PRIVATE_RELAYS_LIST) and datetime.now().timestamp() <= blockstamp.block_timestamp + variables.BUNDLE_TIMEOUT_SECONDS
-
-    def _get_sm_contract(self, address: ChecksumAddress) -> NodeOperatorRegistry:
-        return cast(
-            NodeOperatorRegistry,
-            self.w3.eth.contract(
-                address=address,
-                ContractFactoryClass=NodeOperatorRegistry,
-            )
-        )
-
-    def _process_report_data(self, blockstamp: ReferenceBlockStamp, report_data: tuple, report_hash: HexBytes):
-        if not self._use_private_relays(blockstamp):
-            super()._process_report_data(blockstamp, report_data, report_hash)
-            return
-
-        if not self._is_main_data_submittable(report_hash):
-            return
-
-        contract_version = self.report_contract.get_contract_version(blockstamp.block_hash)
-
-        logger.info({'msg': f'Send report data via private relay. Contract version: [{contract_version}]'})
-        txs = [self.report_contract.submit_report_data(report_data, contract_version)]
-
-        logger.info({'msg': 'Bundle extra data transactions.'})
-        extra_data = self.get_extra_data(blockstamp)
-        if extra_data.format == FormatList.EXTRA_DATA_FORMAT_LIST_EMPTY.value:
-            txs.append(self.report_contract.submit_report_extra_data_empty())
-        else:
-            for tx_data in extra_data.extra_data_list:
-                txs.append(self.report_contract.submit_report_extra_data_list(tx_data))
-
-        logger.info({'msg': 'Bundle reward distribution transactions.'})
-        staking_modules = self.w3.lido_contracts.staking_router.get_staking_modules()
-        for staking_module in staking_modules:
-            ism: NodeOperatorRegistry = self._get_sm_contract(staking_module.staking_module_address)
-
-            if ism.get_type() == CURATED_MODULE_TYPE:
-                txs.append(ism.distribute_reward())
-
-        logger.info({'msg': f'Prepared bundle. Txs count: {len(txs)}'})
-        TransactionBundle.send_tx_bundle(self.w3, txs)

src/modules/accounting/accounting.py

@@ -310,24 +310,11 @@ def _process_report_hash(self, blockstamp: ReferenceBlockStamp, report_hash: Hex
         return None
 
     def _process_report_data(self, blockstamp: ReferenceBlockStamp, report_data: tuple, report_hash: HexBytes):
-        if not self._is_main_data_submittable(report_hash):
-            return
-
-        self._sleep_delay(blockstamp)
-
-        contract_version = self.report_contract.get_contract_version(blockstamp.block_hash)
-
-        logger.info({'msg': f'Send report data. Contract version: [{contract_version}]'})
-        # If data already submitted transaction will be locally reverted, no need to check status manually
-        self._submit_report(report_data, contract_version)
-
-    def _is_main_data_submittable(self, report_hash: HexBytes) -> bool:
-        """Checks if provided data can be submitted to the contract"""
         latest_blockstamp, member_info = self._get_latest_data()
 
         if member_info.current_frame_consensus_report == ZERO_HASH:
             logger.info({'msg': 'Quorum is not ready.'})
-            return False
+            return
 
         if HexBytes(member_info.current_frame_consensus_report) != report_hash:
             msg = 'Oracle`s hash differs from consensus report hash.'
@@ -336,16 +323,11 @@ def _is_main_data_submittable(self, report_hash: HexBytes) -> bool:
                 'consensus_report_hash': HexBytes(member_info.current_frame_consensus_report).hex(),
                 'report_hash': report_hash.hex(),
             })
-            return False
+            return
 
         if self.is_main_data_submitted(latest_blockstamp):
             logger.info({'msg': 'Main data already submitted.'})
-            return False
-
-        return True
-
-    def _sleep_delay(self, blockstamp: ReferenceBlockStamp):
-        latest_blockstamp = self._get_latest_blockstamp()
+            return
 
         slots_to_sleep = self._get_slot_delay_before_data_submit(latest_blockstamp)
         if slots_to_sleep:
@@ -355,11 +337,21 @@ def _sleep_delay(self, blockstamp: ReferenceBlockStamp):
             for _ in range(slots_to_sleep):
                 sleep(chain_configs.seconds_per_slot)
 
-                latest_blockstamp = self._get_latest_blockstamp()
+                latest_blockstamp, member_info = self._get_latest_data()
                 if self.is_main_data_submitted(latest_blockstamp):
                     logger.info({'msg': 'Main data already submitted.'})
                     return
 
+        if self.is_main_data_submitted(latest_blockstamp):
+            logger.info({'msg': 'Main data already submitted.'})
+            return
+
+        contract_version = self.report_contract.get_contract_version(blockstamp.block_hash)
+
+        logger.info({'msg': f'Send report data. Contract version: [{contract_version}]'})
+        # If data already submitted transaction will be locally reverted, no need to check status manually
+        self._submit_report(report_data, contract_version)
+
     def _get_latest_data(self) -> tuple[BlockStamp, MemberInfo]:
         latest_blockstamp = self._get_latest_blockstamp()
         logger.debug({'msg': 'Get latest blockstamp.', 'value': latest_blockstamp})

src/modules/submodules/consensus.py

@@ -270,11 +270,10 @@ def _no_predicate(self, node_operator: NodeOperatorStats) -> tuple:
 
     @staticmethod
     def _no_force_predicate(node_operator: NodeOperatorStats) -> int:
-        # return ValidatorExitIterator._get_expected_validators_diff(
-        #     node_operator.predictable_validators,
-        #     node_operator.force_exit_to,
-        # )
-        return 0
+        return ValidatorExitIterator._get_expected_validators_diff(
+            node_operator.predictable_validators,
+            node_operator.force_exit_to,
+        )
 
     @staticmethod
     def _no_soft_predicate(node_operator: NodeOperatorStats) -> int:

src/providers/execution/contracts/staking_module.py

@@ -85,13 +85,6 @@
 
 CACHE_PATH: Final = Path(os.getenv("CACHE_PATH", "."))
 
-PRIVATE_RELAYS_LIST = []
-if PRIVATE_RELAYS_STR := os.getenv('PRIVATE_RELAYS_LIST', ''):
-    PRIVATE_RELAYS_LIST = PRIVATE_RELAYS_STR.split(',')
-
-BUNDLE_GAS_LIMIT_FOR_EACH_TX = int(os.getenv('BUNDLE_GAS_LIMIT_FOR_EACH_TX', 7_000_000))
-# Time in seconds after which bundling will be skipped and the default method will be used to send the transactions.
-BUNDLE_TIMEOUT_SECONDS = int(os.getenv('BUNDLE_TIMEOUT_SECONDS', 15 * 60 + 2 * 32 * 12))
 
 def check_all_required_variables(module: OracleModule):
     errors = check_uri_required_variables()
@@ -151,7 +144,6 @@ def raise_from_errors(errors):
         'HEALTHCHECK_SERVER_PORT': HEALTHCHECK_SERVER_PORT,
         'MAX_CYCLE_LIFETIME_IN_SECONDS': MAX_CYCLE_LIFETIME_IN_SECONDS,
         'CACHE_PATH': CACHE_PATH,
-        'PRIVATE_RELAYS_LIST': PRIVATE_RELAYS_LIST,
     }.items()
 }