Merge pull request #325 from lidofinance/develop

Develop

Author: F4ever

.pre-commit-config.yaml

@@ -22,6 +22,6 @@ repos:
   hooks:
     # Run the linter.
     - id: ruff
-      args: [ --fix ]
+      args: [ --fix, --extend-ignore=B019 ]
     # Run the formatter.
     - id: ruff-format

README.md

@@ -45,6 +45,14 @@ Unvetting is the proces of decreasing approved depositable signing keys.
 4. Send metrics and logs to grafana
 5. Setup alerts
 
+## Redeployment
+
+Next cases requires bot restart:
+- Contract update
+- New staking module added or removed
+- DSM contract update
+- New guardian added or removed
+
 ## Variables
 
 ### Required variables

pyproject.toml

@@ -41,6 +41,7 @@ markers = [
 line-length = 140
 
 [tool.ruff.lint]
+ignore = ["B019"]
 extend-select = [
     # pycodestyle
     "E",

src/blockchain/contracts/deposit_security_module.py

@@ -1,11 +1,11 @@
 import logging
+from functools import lru_cache
 
 from blockchain.contracts.base_interface import ContractInterface
 from eth_account.account import VRS
 from eth_typing import ChecksumAddress, Hash32
 from metrics.metrics import CAN_DEPOSIT
 from web3.contract.contract import ContractFunction
-from web3.exceptions import ABIFunctionNotFound, ContractLogicError
 from web3.types import BlockIdentifier
 
 logger = logging.getLogger(__name__)
@@ -14,18 +14,21 @@
 class DepositSecurityModuleContract(ContractInterface):
     abi_path = './interfaces/DepositSecurityModule.json'
 
+    @lru_cache(maxsize=1)
     def get_guardian_quorum(self, block_identifier: BlockIdentifier = 'latest') -> int:
         """Returns number of valid guardian signatures required to vet (depositRoot, nonce) pair."""
         response = self.functions.getGuardianQuorum().call(block_identifier=block_identifier)
         logger.info({'msg': 'Call `getGuardianQuorum()`.', 'value': response, 'block_identifier': repr(block_identifier)})
         return response
 
+    @lru_cache(maxsize=1)
     def get_guardians(self, block_identifier: BlockIdentifier = 'latest') -> list[ChecksumAddress]:
         """Returns guardian committee member list."""
         response = self.functions.getGuardians().call(block_identifier=block_identifier)
         logger.info({'msg': 'Call `getGuardians()`.', 'value': response, 'block_identifier': repr(block_identifier)})
         return response
 
+    @lru_cache(maxsize=1)
     def get_attest_message_prefix(self, block_identifier: BlockIdentifier = 'latest') -> bytes:
         response = self.functions.ATTEST_MESSAGE_PREFIX().call(block_identifier=block_identifier)
         logger.info({'msg': 'Call `ATTEST_MESSAGE_PREFIX()`.', 'value': response.hex(), 'block_identifier': repr(block_identifier)})
@@ -85,11 +88,13 @@ def deposit_buffered_ether(
         )
         return tx
 
+    @lru_cache(maxsize=1)
     def get_pause_message_prefix(self, block_identifier: BlockIdentifier = 'latest') -> bytes:
         response = self.functions.PAUSE_MESSAGE_PREFIX().call(block_identifier=block_identifier)
         logger.info({'msg': 'Call `PAUSE_MESSAGE_PREFIX()`.', 'value': response.hex(), 'block_identifier': repr(block_identifier)})
         return response
 
+    @lru_cache(maxsize=1)
     def get_pause_intent_validity_period_blocks(self, block_identifier: BlockIdentifier = 'latest') -> int:
         """Returns current `pauseIntentValidityPeriodBlocks` contract parameter (see `pauseDeposits`)."""
         response = self.functions.getPauseIntentValidityPeriodBlocks().call(block_identifier=block_identifier)
@@ -120,18 +125,9 @@ def pause_deposits(
         logger.info({'msg': f'Build `pauseDeposits({block_number}, {staking_module_id}, {guardian_signature})` tx.'})
         return tx
 
+    @lru_cache(maxsize=1)
     def version(self, block_identifier: BlockIdentifier = 'latest') -> int:
-        try:
-            response = self.functions.VERSION().call(block_identifier=block_identifier)
-        except (ContractLogicError, ABIFunctionNotFound):
-            logger.info(
-                {
-                    'msg': 'Call `VERSION()`.',
-                    'value': 'Error: Contract logic error',
-                    'block_identifier': repr(block_identifier),
-                }
-            )
-            return 1
+        response = self.functions.VERSION().call(block_identifier=block_identifier)
 
         logger.info(
             {
@@ -195,6 +191,7 @@ def pause_deposits_v2(
         logger.info({'msg': f'Build `pauseDeposits({block_number}, {guardian_signature})` tx.'})
         return tx
 
+    @lru_cache(maxsize=1)
     def get_unvet_message_prefix(self, block_identifier: BlockIdentifier = 'latest') -> bytes:
         response = self.functions.UNVET_MESSAGE_PREFIX().call(block_identifier=block_identifier)
         logger.info({'msg': 'Call `UNVET_MESSAGE_PREFIX()`.', 'value': response.hex(), 'block_identifier': repr(block_identifier)})
@@ -241,6 +238,7 @@ def is_deposits_paused(self, block_identifier: BlockIdentifier = 'latest') -> bo
         )
         return response
 
+    @lru_cache(maxsize=1)
     def get_max_operators_per_unvetting(self, block_identifier: BlockIdentifier = 'latest') -> int:
         response = self.functions.getMaxOperatorsPerUnvetting().call(block_identifier=block_identifier)
         logger.info(

src/blockchain/contracts/staking_router.py

@@ -1,4 +1,5 @@
 import logging
+from functools import lru_cache
 
 from blockchain.contracts.base_interface import ContractInterface
 from web3.types import BlockIdentifier, Wei
@@ -9,6 +10,7 @@
 class StakingRouterContract(ContractInterface):
     abi_path = './interfaces/StakingRouter.json'
 
+    @lru_cache(maxsize=1)
     def get_contract_version(self, block_identifier: BlockIdentifier = 'latest') -> int:
         response = self.functions.getContractVersion().call(block_identifier=block_identifier)
         logger.info(
@@ -20,6 +22,7 @@ def get_contract_version(self, block_identifier: BlockIdentifier = 'latest') ->
         )
         return response
 
+    @lru_cache(maxsize=1)
     def get_staking_module_ids(self, block_identifier: BlockIdentifier = 'latest') -> list[int]:
         """Returns the ids of all registered staking modules"""
         response = self.functions.getStakingModuleIds().call(block_identifier=block_identifier)

src/blockchain/executor.py

@@ -47,8 +47,10 @@ def execute_as_daemon(self) -> None:
     def _wait_for_new_block_and_execute(self) -> Any:
         healthcheck_pulse.pulse()
 
-        if self.w3.lido.has_contract_address_changed():
-            logger.info({'msg': 'Contract addresses have been updated.'})
+        # To avoid re-fetching contract addresses every cycle and decrease consumtion
+        # Requires restart each protocol upgrade including DSM contract or Staking Modules.
+        # if self.w3.lido.has_contract_address_changed():
+        #     logger.info({'msg': 'Contract addresses have been updated.'})
 
         latest_block = self._exception_handler(self._wait_until_next_block)
         result = self._exception_handler(self._execute_function, latest_block)

src/bots/depositor.py

@@ -105,17 +105,21 @@ def __init__(
     def execute(self, block: BlockData) -> bool:
         self._check_balance()
 
-        for module_id in self._get_preferred_to_deposit_modules():
+        modules_to_deposit = self._get_preferred_to_deposit_modules()
+
+        if not modules_to_deposit:
+            # No modules expected. Long sleep.
+            return True
+
+        for module_id in modules_to_deposit:
             logger.info({'msg': f'Do deposit to module with id: {module_id}.'})
 
             result = self._deposit_to_module(module_id)
             logger.info({'msg': f'Deposit status to Module[{module_id}]: {result}.', 'value': result})
 
-            if variables.DEPOSIT_TO_FIRST_HEALTHY_MODULE_ONLY or result:
+            if result:
                 return result
 
-            logger.warning({'msg': f'Deposit to module with id: {module_id} failed.'})
-
         return False
 
     def _check_balance(self):
@@ -128,11 +132,13 @@ def _check_balance(self):
 
         guardians = self.w3.lido.deposit_security_module.get_guardians()
         providers = [self.w3]
+
         if self._onchain_transport_w3 is not None:
             providers.append(self._onchain_transport_w3)
+
         for address in guardians:
             for provider in providers:
-                balance = self.w3.eth.get_balance(address)
+                balance = provider.eth.get_balance(address)
                 GUARDIAN_BALANCE.labels(address=address, chain_id=provider.eth.chain_id).set(balance)
 
     def _deposit_to_module(self, module_id: int) -> bool:
@@ -251,18 +257,22 @@ def _fetch_actual_messages(self) -> list[BotMessage]:
         return self.message_storage.get_messages_and_actualize(lambda x: sign_filter(x) and actualize_filter(x))
 
     def _get_preferred_to_deposit_modules(self) -> list[int]:
-        # gather quorum
-        now = datetime.now()
-        for module_id in variables.DEPOSIT_MODULES_WHITELIST:
-            if self._get_quorum(module_id):
-                self._module_last_heart_beat[module_id] = now
-
         # filter out non allow-listed modules
         module_ids = [
             module_id
             for module_id in self.w3.lido.staking_router.get_staking_module_ids()
             if module_id in variables.DEPOSIT_MODULES_WHITELIST
         ]
+
+        # gather quorum
+        now = datetime.now()
+        for module_id in module_ids:
+            # Just for metrics
+            self._select_strategy(module_id).is_gas_price_ok(module_id)
+
+            if self._get_quorum(module_id):
+                self._module_last_heart_beat[module_id] = now
+
         # get digests for all the modules
         module_digests = self.w3.lido.staking_router.get_staking_module_digests(module_ids)
         # sort modules by validator count
@@ -277,6 +287,7 @@ def _get_preferred_to_deposit_modules(self) -> list[int]:
         # take all the modules in sorted order until the first healthy one(including)
         result = self._take_until_first_healthy_module(modules_healthiness)
         logger.info({'msg': f'Module iteration order {result}.'})
+
         return result
 
     def _is_module_healthy(self, module_id: int) -> bool:
@@ -305,4 +316,7 @@ def _take_until_first_healthy_module(sorted_modules_healthiness: list[Tuple[int,
             module_ids.append(module_id)
             if is_healthy:
                 break
+        else:
+            # If all modules are unhealthy
+            return []
         return module_ids

src/bots/pauser.py

@@ -26,7 +26,8 @@ def run_pauser(w3: Web3):
     e = Executor(
         w3,
         pause.execute,
-        variables.BLOCKS_BETWEEN_EXECUTION,
+        # Always one due to high priority
+        1,
         variables.MAX_CYCLE_LIFETIME_IN_SECONDS,
     )
     logger.info({'msg': 'Execute pauser as daemon.'})

src/variables.py

@@ -88,7 +88,9 @@
 # List of ids of staking modules in which the depositor bot will make deposits
 _env_whitelist = os.getenv('DEPOSIT_MODULES_WHITELIST', '').strip()
 DEPOSIT_MODULES_WHITELIST = [int(module_id) for module_id in _env_whitelist.split(',')] if _env_whitelist else []
-BLOCKS_BETWEEN_EXECUTION = int(os.getenv('BLOCKS_BETWEEN_EXECUTION', 1))
+# Same as min deposit block distance on mainnet for all modules
+# https://etherscan.io/address/0xFdDf38947aFB03C621C71b06C9C70bce73f12999#readProxyContract#F38
+BLOCKS_BETWEEN_EXECUTION = int(os.getenv('BLOCKS_BETWEEN_EXECUTION', 25))
 
 """
 GAS_ADDENDUM is used to increase number of deposits during to calm market. The value should be increased if bot

tests/bots/test_depositor.py

@@ -43,20 +43,22 @@ def test_get_preferred_to_deposit_modules(self, mock_datetime):
         # Mock staking router module IDs and digests
         self.mock_w3.lido.staking_router.get_staking_module_ids.return_value = [1, 2, 3]
         self.mock_w3.lido.staking_router.get_staking_module_digests.return_value = [
-            [0, 0, [1], [5, 2]],  # Module 1: 3 validators
-            [0, 0, [2], [7, 6]],  # Module 2: 1 validator
-            [0, 0, [3], [10, 4]],  # Module 3: 6 validators
+            [0, 0, [1], [5, 8]],  # Module 1: 3 active validators
+            [0, 0, [2], [7, 8]],  # Module 2: 1 active validator
+            [0, 0, [3], [10, 16]],  # Module 3: 6 active validators
         ]
+        self.bot._get_quorum = Mock()
+        self.bot._select_strategy = Mock()
 
         # Mock module healthiness and quorum
-        self.bot._get_quorum = MagicMock(side_effect=[True, False, True])
+        # Module ID:                                          2      1      3
         self.bot._is_module_healthy = MagicMock(side_effect=[True, False, True])
 
         # Call the method
         result = self.bot._get_preferred_to_deposit_modules()
 
-        # Expected output: Module 3 (6 validators, healthy)
-        self.assertEqual([3], result)
+        # Expected output: Module 2 (1 active)
+        self.assertEqual([2], result)
 
         # Verify calls to dependent methods
         self.bot._get_quorum.assert_any_call(1)
@@ -84,27 +86,26 @@ def test_no_healthy_modules(self):
         # Mock staking router module IDs and digests
         self.mock_w3.lido.staking_router.get_staking_module_ids.return_value = [1, 2]
         self.mock_w3.lido.staking_router.get_staking_module_digests.return_value = [
-            [0, 0, [1], [3, 1]],  # Module 1: 2 validators
-            [0, 0, [2], [7, 5]],  # Module 2: 2 validators
+            [0, 0, [1], [3, 5]],  # Module 1: 2 validators
+            [0, 0, [2], [7, 9]],  # Module 2: 2 validators
         ]
+        self.bot._get_quorum = Mock()
 
         # Mock module healthiness and quorum
-        self.bot._get_quorum = MagicMock(side_effect=[True, True, True])
         self.bot._is_module_healthy = MagicMock(side_effect=[False, False])
 
         # Call the method
         result = self.bot._get_preferred_to_deposit_modules()
 
-        # Expected output: Include all modules as no healthy modules are found
-        self.assertEqual([1, 2], result)
+        self.assertEqual([], result)
 
     def test_module_sorting_by_validator_difference(self):
         # Mock staking router module IDs and digests
         self.mock_w3.lido.staking_router.get_staking_module_ids.return_value = [1, 2, 3]
         self.mock_w3.lido.staking_router.get_staking_module_digests.return_value = [
-            [0, 0, [1], [6, 2]],  # Module 1: 4 validators
-            [0, 0, [2], [8, 3]],  # Module 2: 5 validators
-            [0, 0, [3], [7, 6]],  # Module 3: 1 validator
+            [0, 0, [1], [6, 10]],  # Module 1: 4 validators
+            [0, 0, [2], [8, 13]],  # Module 2: 5 validators
+            [0, 0, [3], [7, 8]],  # Module 3: 1 validator
         ]
 
         # Mock module healthiness and quorum
@@ -114,8 +115,8 @@ def test_module_sorting_by_validator_difference(self):
         # Call the method
         result = self.bot._get_preferred_to_deposit_modules()
 
-        # Expected output: Sorted by validator difference: Module 2, Module 1, Module 3
-        self.assertEqual([2], result)
+        # Expected output: Sorted by validator difference: Module 3, Module 1, Module 2
+        self.assertEqual([3], result)
 
 
 @pytest.fixture
@@ -171,13 +172,23 @@ def test_depositor_one_module_deposited(depositor_bot, block_data):
             (0, 0, (2,), (0, 10, 10)),
         ]
     )
+    depositor_bot._general_strategy.is_gas_price_ok = Mock(return_value=True)
+    depositor_bot._general_strategy.deposited_keys_amount = Mock(return_value=10)
     depositor_bot._check_balance = Mock()
     depositor_bot._deposit_to_module = Mock(return_value=True)
-    depositor_bot.execute(block_data)
+    assert depositor_bot.execute(block_data)
 
     assert depositor_bot._deposit_to_module.call_count == 1
 
 
+@pytest.mark.unit
+def test_depositor_no_modules_to_deposit(depositor_bot, block_data):
+    depositor_bot._check_balance = Mock()
+    depositor_bot._get_preferred_to_deposit_modules = Mock(return_value=[])
+    # Make sure if no modules are deposited, the bot goes to long sleep
+    assert depositor_bot.execute(block_data)
+
+
 @pytest.mark.unit
 @pytest.mark.parametrize(
     'is_depositable,quorum,is_gas_price_ok,is_deposited_keys_amount_ok',
@@ -379,27 +390,3 @@ def test_depositor_bot(
     db.message_storage.messages = deposit_messages
     assert db.execute(latest)
     assert web3_lido_integration.lido.staking_router.get_staking_module_nonce(module_id) == old_module_nonce + 1
-
-
-@pytest.mark.unit
-def test_depositor_execute(web3_lido_unit, depositor_bot):
-    depositor_bot._check_balance = Mock()
-
-    depositor_bot._get_preferred_to_deposit_modules = Mock(return_value=[1, 2])
-
-    # Check unsuccess deposit to first module only
-    variables.DEPOSIT_TO_FIRST_HEALTHY_MODULE_ONLY = True
-    depositor_bot._deposit_to_module = Mock(return_value=False)
-    depositor_bot.execute(None)
-    assert depositor_bot._deposit_to_module.call_count == 1
-
-    # Check deposit to both modules
-    variables.DEPOSIT_TO_FIRST_HEALTHY_MODULE_ONLY = False
-    depositor_bot._deposit_to_module = Mock(return_value=False)
-    depositor_bot.execute(None)
-    assert depositor_bot._deposit_to_module.call_count == 2
-
-    # Check success to first module
-    depositor_bot._deposit_to_module = Mock(return_value=True)
-    depositor_bot.execute(None)
-    assert depositor_bot._deposit_to_module.call_count == 1