feat: add integration tests for lazy oracle

Author: tamtamchik

src/modules/accounting/accounting.py

@@ -433,6 +433,13 @@ def _handle_vaults_report(self, blockstamp: ReferenceBlockStamp) -> VaultsReport
             block_identifier=blockstamp.block_hash,
         )
 
+        vaults_total_values = self.staking_vaults.get_vaults_total_values(
+            vaults=vaults,
+            validators=validators,
+            pending_deposits=pending_deposits,
+            validator_stages=validator_stages,
+        )
+
         core_apr_ratio = calculate_gross_core_apr(
             pre_total_ether=simulation.pre_total_pooled_ether,
             pre_total_shares=simulation.pre_total_shares,
@@ -442,13 +449,6 @@ def _handle_vaults_report(self, blockstamp: ReferenceBlockStamp) -> VaultsReport
             time_elapsed_seconds=self._get_time_elapsed_seconds_from_prev_report(blockstamp),
         )
 
-        vaults_total_values = self.staking_vaults.get_vaults_total_values(
-            vaults=vaults,
-            validators=validators,
-            pending_deposits=pending_deposits,
-            validator_stages=validator_stages,
-        )
-
         latest_onchain_ipfs_report_data = self.staking_vaults.get_latest_onchain_ipfs_report_data(blockstamp.block_hash)
         vaults_fees = self.staking_vaults.get_vaults_fees(
             blockstamp=blockstamp,

src/providers/execution/contracts/lazy_oracle.py

@@ -13,12 +13,11 @@
 from src.providers.execution.base_interface import ContractInterface
 from src.utils.abi import named_tuple_to_dataclass
 from src.utils.cache import global_lru_cache as lru_cache
-from src.utils.types import hex_str_to_bytes
 
 logger = logging.getLogger(__name__)
 
 
-class VaultsLazyOracleContract(ContractInterface):
+class LazyOracleContract(ContractInterface):
     abi_path = './assets/LazyOracle.json'
 
     @lru_cache(maxsize=1)
@@ -28,28 +27,24 @@ def get_vaults_count(self, block_identifier: BlockIdentifier = 'latest') -> int:
         """
         response = self.functions.vaultsCount.call(block_identifier=block_identifier)
 
-        logger.info(
-            {
-                'msg': 'Call `vaultsCount().',
-                'value': response,
-                'block_identifier': repr(block_identifier),
-                'to': self.address,
-            }
-        )
+        logger.info({
+            'msg': 'Call `vaultsCount().',
+            'value': response,
+            'block_identifier': repr(block_identifier),
+            'to': self.address,
+        })
 
         return response
 
     def get_latest_report_data(self, block_identifier: BlockIdentifier = 'latest') -> OnChainIpfsVaultReportData:
         response = self.functions.latestReportData.call(block_identifier=block_identifier)
 
-        logger.info(
-            {
-                'msg': 'Call `latestReportData()`.',
-                'value': response,
-                'block_identifier': repr(block_identifier),
-                'to': self.address,
-            }
-        )
+        logger.info({
+            'msg': 'Call `latestReportData()`.',
+            'value': response,
+            'block_identifier': repr(block_identifier),
+            'to': self.address,
+        })
 
         response = named_tuple_to_dataclass(response, OnChainIpfsVaultReportData)
         return response
@@ -62,33 +57,29 @@ def get_vaults(self, offset: int, limit: int, block_identifier: BlockIdentifier
 
         out: list[VaultInfo] = []
         for vault in response:
-            out.append(
-                VaultInfo(
-                    vault=vault.vault,
-                    aggregated_balance=vault.aggregateBalance,
-                    in_out_delta=vault.inOutDelta,
-                    withdrawal_credentials=Web3.to_hex(vault.withdrawalCredentials),
-                    liability_shares=vault.liabilityShares,
-                    max_liability_shares=vault.maxLiabilityShares,
-                    mintable_st_eth=vault.mintableStETH,
-                    share_limit=vault.shareLimit,
-                    reserve_ratio_bp=vault.reserveRatioBP,
-                    forced_rebalance_threshold_bp=vault.forcedRebalanceThresholdBP,
-                    infra_fee_bp=vault.infraFeeBP,
-                    liquidity_fee_bp=vault.liquidityFeeBP,
-                    reservation_fee_bp=vault.reservationFeeBP,
-                    pending_disconnect=vault.pendingDisconnect,
-                )
-            )
-
-        logger.info(
-            {
-                'msg': f'Call `batchVaultsInfo({offset}, {limit}).',
-                'value': response,
-                'block_identifier': repr(block_identifier),
-                'to': self.address,
-            }
-        )
+            out.append(VaultInfo(
+                vault=vault.vault,
+                aggregated_balance=vault.aggregateBalance,
+                in_out_delta=vault.inOutDelta,
+                withdrawal_credentials=Web3.to_hex(vault.withdrawalCredentials),
+                liability_shares=vault.liabilityShares,
+                max_liability_shares=vault.maxLiabilityShares,
+                mintable_st_eth=vault.mintableStETH,
+                share_limit=vault.shareLimit,
+                reserve_ratio_bp=vault.reserveRatioBP,
+                forced_rebalance_threshold_bp=vault.forcedRebalanceThresholdBP,
+                infra_fee_bp=vault.infraFeeBP,
+                liquidity_fee_bp=vault.liquidityFeeBP,
+                reservation_fee_bp=vault.reservationFeeBP,
+                pending_disconnect=vault.pendingDisconnect,
+            ))
+
+        logger.info({
+            'msg': f'Call `batchVaultsInfo({offset}, {limit}).',
+            'value': response,
+            'block_identifier': repr(block_identifier),
+            'to': self.address,
+        })
 
         return out
 
@@ -126,14 +117,12 @@ def get_validator_stages(
             batch = list(map(HexBytes, pubkeys[i : i + batch_size]))
             response = self.functions.batchValidatorStages(batch).call(block_identifier=block_identifier)
 
-            logger.debug(
-                {
-                    'msg': 'Call `batchValidatorStages()`.',
-                    'count': len(batch),
-                    'block_identifier': repr(block_identifier),
-                    'to': self.address,
-                }
-            )
+            logger.debug({
+                'msg': 'Call `batchValidatorStages()`.',
+                'count': len(batch),
+                'block_identifier': repr(block_identifier),
+                'to': self.address,
+            })
 
             # Assume response is a list of ints corresponding to ValidatorStage enum values
             for pubkey, stage in zip(batch, response):

src/services/staking_vaults.py

@@ -125,7 +125,7 @@ def get_vaults_total_values(
                 # For not-yet-eligible validators, use lazy oracle stages:
                 # - PREDEPOSITED: add 1 ETH (guaranteed)
                 # - ACTIVATED: add full balance + pending deposits
-                # All other stages are skipped as not related to the non eligible for activation validators
+                # All other stages are skipped as not related to the non-eligible for activation validators
                 else:
                     stage = validator_stages.get(pubkey)
                     if stage == ValidatorStage.PREDEPOSITED:

src/web3py/extensions/contracts.py

@@ -12,19 +12,23 @@
 from src.providers.execution.contracts.accounting_oracle import AccountingOracleContract
 from src.providers.execution.contracts.burner import BurnerContract
 from src.providers.execution.contracts.exit_bus_oracle import ExitBusOracleContract
+from src.providers.execution.contracts.lazy_oracle import LazyOracleContract
 from src.providers.execution.contracts.lido import LidoContract
 from src.providers.execution.contracts.lido_locator import LidoLocatorContract
-from src.providers.execution.contracts.oracle_daemon_config import OracleDaemonConfigContract
-from src.providers.execution.contracts.oracle_report_sanity_checker import OracleReportSanityCheckerContract
+from src.providers.execution.contracts.oracle_daemon_config import (
+    OracleDaemonConfigContract,
+)
+from src.providers.execution.contracts.oracle_report_sanity_checker import (
+    OracleReportSanityCheckerContract,
+)
 from src.providers.execution.contracts.staking_router import StakingRouterContract
-from src.providers.execution.contracts.lazy_oracle import VaultsLazyOracleContract
 from src.providers.execution.contracts.vault_hub import VaultHubContract
-
-from src.providers.execution.contracts.withdrawal_queue_nft import WithdrawalQueueNftContract
-from src.types import BlockStamp, SlotNumber, WithdrawalVaultBalance, ELVaultBalance
+from src.providers.execution.contracts.withdrawal_queue_nft import (
+    WithdrawalQueueNftContract,
+)
+from src.types import BlockStamp, ELVaultBalance, SlotNumber, WithdrawalVaultBalance
 from src.utils.cache import global_lru_cache as lru_cache
 
-
 logger = logging.getLogger(__name__)
 
 
@@ -41,7 +45,7 @@ class LidoContracts(Module):
     oracle_daemon_config: OracleDaemonConfigContract
     burner: BurnerContract
     accounting: AccountingContract
-    lazy_oracle: VaultsLazyOracleContract
+    lazy_oracle: LazyOracleContract
     vault_hub: VaultHubContract
 
     def __init__(self, w3: Web3):

tests/integration/conftest.py

@@ -8,19 +8,30 @@
 from src.providers.execution.contracts.accounting_oracle import AccountingOracleContract
 from src.providers.execution.contracts.burner import BurnerContract
 from src.providers.execution.contracts.cs_accounting import CSAccountingContract
-from src.providers.execution.contracts.cs_fee_distributor import CSFeeDistributorContract
+from src.providers.execution.contracts.cs_fee_distributor import (
+    CSFeeDistributorContract,
+)
 from src.providers.execution.contracts.cs_fee_oracle import CSFeeOracleContract
 from src.providers.execution.contracts.cs_module import CSModuleContract
-from src.providers.execution.contracts.cs_parameters_registry import CSParametersRegistryContract
+from src.providers.execution.contracts.cs_parameters_registry import (
+    CSParametersRegistryContract,
+)
 from src.providers.execution.contracts.cs_strikes import CSStrikesContract
 from src.providers.execution.contracts.exit_bus_oracle import ExitBusOracleContract
+from src.providers.execution.contracts.lazy_oracle import LazyOracleContract
 from src.providers.execution.contracts.lido import LidoContract
 from src.providers.execution.contracts.lido_locator import LidoLocatorContract
-from src.providers.execution.contracts.oracle_daemon_config import OracleDaemonConfigContract
-from src.providers.execution.contracts.oracle_report_sanity_checker import OracleReportSanityCheckerContract
+from src.providers.execution.contracts.oracle_daemon_config import (
+    OracleDaemonConfigContract,
+)
+from src.providers.execution.contracts.oracle_report_sanity_checker import (
+    OracleReportSanityCheckerContract,
+)
 from src.providers.execution.contracts.staking_router import StakingRouterContract
-from src.providers.execution.contracts.lazy_oracle import VaultsLazyOracleContract
-from src.providers.execution.contracts.withdrawal_queue_nft import WithdrawalQueueNftContract
+from src.providers.execution.contracts.vault_hub import VaultHubContract
+from src.providers.execution.contracts.withdrawal_queue_nft import (
+    WithdrawalQueueNftContract,
+)
 
 
 @pytest.fixture
@@ -136,11 +147,20 @@ def burner_contract(web3_provider_integration, lido_locator_contract):
 def vault_hub_contract(web3_provider_integration, lido_locator_contract):
     return get_contract(
         web3_provider_integration,
-        VaultsLazyOracleContract,
+        VaultHubContract,
         lido_locator_contract.vault_hub(),
     )
 
 
+@pytest.fixture
+def lazy_oracle_contract(web3_provider_integration, lido_locator_contract):
+    return get_contract(
+        web3_provider_integration,
+        LazyOracleContract,
+        lido_locator_contract.lazy_oracle(),
+    )
+
+
 # ╔══════════════════════════════════════════════════════════════════════════════════════════════════╗
 # ║                                          CSM contracts                                           ║
 # ╚══════════════════════════════════════════════════════════════════════════════════════════════════╝

tests/integration/contracts/test_accounting.py

@@ -1,13 +1,16 @@
 import pytest
 from web3.types import Wei
 
-from src.modules.accounting.types import ReportSimulationPayload, ReportSimulationResults
+from src.modules.accounting.types import (
+    ReportSimulationPayload,
+    ReportSimulationResults,
+)
 from tests.integration.contracts.contract_utils import check_contract, check_value_type
 
 
 @pytest.mark.testnet  # TODO: Bounded to hoodie due to st. vaults task, move to mainnet after release
 @pytest.mark.integration
-@pytest.mark.skip
+@pytest.mark.skip("Some real numbers required for simulation to pass")
 def test_accounting_contract_call(accounting_contract, caplog):
     check_contract(
         accounting_contract,

tests/integration/contracts/test_lazy_oracle.py

@@ -0,0 +1,31 @@
+import pytest
+from hexbytes import HexBytes
+
+from src.modules.accounting.types import OnChainIpfsVaultReportData
+from tests.integration.contracts.contract_utils import check_contract, check_value_type
+
+
+@pytest.mark.mainnet
+@pytest.mark.integration
+@pytest.mark.skip("LazyOracle contract is not latest on Hoodi.")
+def test_lazy_oracle_contract_call(lazy_oracle_contract, caplog):
+    check_contract(
+        lazy_oracle_contract,
+        [
+            ('get_vaults_count', None, lambda response: check_value_type(response, int)),
+            ('get_latest_report_data', None, lambda response: check_value_type(response, OnChainIpfsVaultReportData)),
+            ('get_vaults', (0, 10), lambda response: check_value_type(response, list)),
+            (
+                'get_validator_stages',
+                (
+                    [
+                        "0x862d53d9e4313374d202f2b28e6ffe64efb0312f9c2663f2eef67b72345faa8932b27f9b9bb7b476d9b5e418fea99124",
+                        "0xa5d9411ef615c74c9240634905d5ddd46dc40a87a09e8cc0332afddb246d291303e452a850917eefe09b3b8c70a307ce",
+                    ],
+                    5,
+                ),
+                lambda response: check_value_type(response, dict),
+            ),
+        ],
+        caplog,
+    )

tests/integration/contracts/test_vault_hub.py

@@ -6,14 +6,14 @@
 @pytest.mark.integration
 class TestStakingVaultsContractsSmoke:
 
-    @pytest.mark.skip
+    @pytest.mark.skip("No events in the range, need to update the test")
     def test_get_burned_events(self, web3_integration):
         events = web3_integration.lido_contracts.vault_hub.get_burned_events(
             BlockNumber(1272666 - 1_000), BlockNumber(1272666)
         )
         assert len(events) != 0
 
-    @pytest.mark.skip
+    @pytest.mark.skip("No events in the range, need to update the test")
     def test_get_minted_events(self, web3_integration):
         events = web3_integration.lido_contracts.vault_hub.get_minted_events(
             BlockNumber(1272666 - 1_000), BlockNumber(1272666)
@@ -26,7 +26,7 @@ def test_get_updated_events(self, web3_integration):
         )
         assert len(events) == 0
 
-    @pytest.mark.skip
+    @pytest.mark.skip("Distribution disabled on devnet")
     def test_staking_fee_aggregate_distribution(self, web3_integration):
         out = web3_integration.lido_contracts.staking_router.get_staking_fee_aggregate_distribution()
         assert 0 != out.lido_fee_bp()