Merge pull request #860 from lidofinance/develop

Develop

Author: F4ever

src/modules/accounting/accounting.py

@@ -332,7 +332,11 @@ def _get_slots_elapsed_from_last_report(self, blockstamp: ReferenceBlockStamp) -
             slots_elapsed = blockstamp.ref_slot - last_ref_slot
         else:
             # https://github.com/lidofinance/core/blob/master/contracts/0.8.9/oracle/HashConsensus.sol#L667
-            slots_elapsed = blockstamp.ref_slot - (frame_config.initial_epoch * chain_conf.slots_per_epoch - 1)
+            prev_slot = max(
+                (frame_config.initial_epoch - frame_config.epochs_per_frame) * chain_conf.slots_per_epoch - 1,
+                0,
+            )
+            slots_elapsed = blockstamp.ref_slot - prev_slot
 
         return slots_elapsed
 

src/services/staking_vaults.py

@@ -803,39 +803,38 @@ def get_vaults_fees(
             current_frame=current_frame,
         )
 
-        # Get the last processing ref slot
-        last_processing_ref_slot: SlotNumber = accounting_oracle.get_last_processing_ref_slot(blockstamp.block_hash)
-        if last_processing_ref_slot:
-            prev_ref_slot = SlotNumber(int(last_processing_ref_slot))
-        else:
-            # Fresh devnet: no previous Oracle report, derive a starting ref slot
-            # This approximates the accounting contract's _get_slots_elapsed_from_last_report
-            initial_ref_slot = frame_config.initial_epoch * chain_config.slots_per_epoch
-            prev_ref_slot = SlotNumber(initial_ref_slot - 1) if initial_ref_slot > 0 else SlotNumber(0)
-
-        slots_per_frame = frame_config.epochs_per_frame * chain_config.slots_per_epoch
-        prev_report_blockstamp = get_blockstamp(
+        # Calculate from block param
+        from_ref_slot: SlotNumber = accounting_oracle.get_last_processing_ref_slot(blockstamp.block_hash)
+
+        # If this is first report
+        if not from_ref_slot:
+            # Time range should include all events from FrameIndex 0 upto current ref slot
+            # Calculate FrameIndex 0 ref slot
+            potential_prev_ref_slot = (frame_config.initial_epoch - frame_config.epochs_per_frame) * chain_config.slots_per_epoch - 1
+            from_ref_slot = SlotNumber(max(potential_prev_ref_slot, 0))
+
+        prev_report_block_number = get_blockstamp(
             cc=self.w3.cc,
-            slot=prev_ref_slot,
-            last_finalized_slot_number=SlotNumber(int(prev_ref_slot) + slots_per_frame),
-        )
+            slot=from_ref_slot,
+            last_finalized_slot_number=blockstamp.slot_number,
+        ).block_number
 
         # Events are fetched forward over (event_start_block, current_block] and applied backward by timestamp.
         events, connected_vaults_set = self._get_vault_events_for_fees(
             vault_hub=vault_hub,
             # Do not include events from last block of last frame
-            from_block=prev_report_blockstamp.block_number + 1,
+            from_block=prev_report_block_number + 1,
             to_block=blockstamp.block_number,
         )
 
         # Missed CL slots produce no EL blocks, so elapsed time must be derived from ref slots.
         current_ref_slot_timestamp = self._get_report_timestamp(blockstamp.ref_slot, chain_config)
-        prev_ref_slot_timestamp = self._get_report_timestamp(prev_ref_slot, chain_config)
+        prev_ref_slot_timestamp = self._get_report_timestamp(from_ref_slot, chain_config)
         report_interval_seconds = current_ref_slot_timestamp - prev_ref_slot_timestamp
         if report_interval_seconds < 0:
             raise ValueError(
                 "Negative report interval."
-                f" {current_ref_slot_timestamp=} {prev_ref_slot_timestamp=} {blockstamp.ref_slot=} {prev_ref_slot=}"
+                f" {current_ref_slot_timestamp=} {prev_ref_slot_timestamp=} {blockstamp.ref_slot=} {from_ref_slot=}"
             )
 
         prev_fee_map, prev_liability_shares_map = self._build_prev_report_maps(prev_ipfs_report)

tests/modules/accounting/staking_vault/test_fee_get_vaults.py

@@ -10,6 +10,7 @@
 from src.services.staking_vaults import StakingVaultsService
 from src.types import FrameNumber, ReferenceBlockStamp, SlotNumber
 from src.utils.apr import get_steth_by_shares
+from tests.factory.blockstamp import BlockStampFactory
 from tests.modules.accounting.staking_vault.conftest import (
     ExtraValueFactory,
     FeeTestConstants,
@@ -41,7 +42,6 @@ def service(self, web3, monkeypatch):
 
         fake_blockstamp = MagicMock()
         fake_blockstamp.block_number = 0
-
         monkeypatch.setattr("src.services.staking_vaults.get_blockstamp", MagicMock(return_value=fake_blockstamp))
 
         return svc
@@ -111,42 +111,100 @@ def test_zero_time_elapsed_allowed(self, service):
 
         assert fees[vault_adr].prev_fee == 0
 
-    def test_initial_epoch_zero_uses_non_negative_prev_ref_slot(self, service):
-        # Setup
+    def test_negative_ref_slot_on_first_report(self, service, monkeypatch):
+        # initial_epoch - frame_epoches <= 0
         vault_adr = VaultAddresses.VAULT_0
         vault = VaultInfoFactory.build(vault=vault_adr, liability_shares=0, max_liability_shares=0)
-        blockstamp = self.make_blockstamp(block=10, slot=100)
 
-        service.w3.lido_contracts.accounting_oracle.get_last_processing_ref_slot.return_value = 0
+        service.w3.lido_contracts.accounting_oracle.get_last_processing_ref_slot.return_value = None
         service._get_prev_vault_ipfs_report = MagicMock(return_value=None)
         service._get_vault_events_for_fees = MagicMock(return_value=({}, set()))
         service._calculate_vault_fee_components = MagicMock(return_value=(Decimal(0), Decimal(0), Decimal(0), 0))
 
-        with patch("src.services.staking_vaults.get_blockstamp", return_value=MagicMock(block_number=0)) as get_bs_mock:
-            # Act
-            service.get_vaults_fees(
-                blockstamp=blockstamp,
-                vaults={vault_adr: vault},
-                vaults_total_values={},
-                latest_onchain_ipfs_report_data=OnChainIpfsVaultReportDataFactory.build(report_cid=""),
-                core_apr_ratio=Decimal("0"),
-                pre_total_pooled_ether=Wei(0),
-                pre_total_shares=0,
-                frame_config=FrameConfig(initial_epoch=0, epochs_per_frame=1, fast_lane_length_slots=0),
-                chain_config=ChainConfig(slots_per_epoch=32, seconds_per_slot=12, genesis_time=0),
-                current_frame=FrameNumber(0),
-            )
+        # Negative prev_slot -> events should be fetched from 0 block
+        blockstamp = self.make_blockstamp(block=3 * 32 - 1, slot=3 * 32 - 1)
+        monkeypatch.setattr(
+            "src.services.staking_vaults.get_blockstamp",
+            lambda cc, slot, last_finalized_slot_number: BlockStampFactory.build(block_number=slot),
+        )
+
+        service.get_vaults_fees(
+            blockstamp=blockstamp,
+            vaults={vault_adr: vault},
+            vaults_total_values={},
+            latest_onchain_ipfs_report_data=OnChainIpfsVaultReportDataFactory.build(report_cid=""),
+            core_apr_ratio=Decimal("0"),
+            pre_total_pooled_ether=Wei(0),
+            pre_total_shares=0,
+            frame_config=FrameConfig(initial_epoch=3, epochs_per_frame=5, fast_lane_length_slots=0),
+            chain_config=ChainConfig(slots_per_epoch=32, seconds_per_slot=12, genesis_time=0),
+            current_frame=FrameNumber(0),
+        )
+
+        service._get_vault_events_for_fees.assert_called_once_with(
+            vault_hub=service.w3.lido_contracts.vault_hub,
+            from_block=1,
+            to_block=3 * 32 - 1,
+        )
 
-        # Assert
-        assert get_bs_mock.call_args.kwargs["slot"] == SlotNumber(0)
         service._calculate_vault_fee_components.assert_called_once_with(
             vault_address=vault_adr,
             vault_info=vault,
             vault_total_value=0,
             vault_events=[],
-            report_interval_seconds=100 * 12,
+            report_interval_seconds=(3 * 32 - 1) * 12,
             prev_ref_slot_timestamp=0,
-            current_ref_slot_timestamp=100 * 12,
+            current_ref_slot_timestamp=(3 * 32 - 1) * 12,
+            core_apr_ratio=Decimal(0),
+            pre_total_pooled_ether=0,
+            pre_total_shares=0,
+            block_timestamps={},
+        )
+
+    def test_first_ref_slot_calculate_on_first_report(self, service, monkeypatch):
+        # initial_epoch - frame_epoches > 0
+        vault_adr = VaultAddresses.VAULT_0
+        vault = VaultInfoFactory.build(vault=vault_adr, liability_shares=0, max_liability_shares=0)
+
+        service.w3.lido_contracts.accounting_oracle.get_last_processing_ref_slot.return_value = None
+        service._get_prev_vault_ipfs_report = MagicMock(return_value=None)
+        service._get_vault_events_for_fees = MagicMock(return_value=({}, set()))
+        service._calculate_vault_fee_components = MagicMock(return_value=(Decimal(0), Decimal(0), Decimal(0), 0))
+
+        monkeypatch.setattr(
+            "src.services.staking_vaults.get_blockstamp",
+            lambda cc, slot, last_finalized_slot_number: BlockStampFactory.build(block_number=slot),
+        )
+
+        # First report -> events should be fetched from initial_epoch - frame_epoches
+        blockstamp = self.make_blockstamp(block=10 * 32 - 1, slot=10 * 32 - 1)
+        service.get_vaults_fees(
+            blockstamp=blockstamp,
+            vaults={vault_adr: vault},
+            vaults_total_values={},
+            latest_onchain_ipfs_report_data=OnChainIpfsVaultReportDataFactory.build(report_cid=""),
+            core_apr_ratio=Decimal("0"),
+            pre_total_pooled_ether=Wei(0),
+            pre_total_shares=0,
+            frame_config=FrameConfig(initial_epoch=10, epochs_per_frame=5, fast_lane_length_slots=0),
+            chain_config=ChainConfig(slots_per_epoch=32, seconds_per_slot=12, genesis_time=0),
+            current_frame=FrameNumber(0),
+        )
+
+        service._get_vault_events_for_fees.assert_called_once_with(
+            vault_hub=service.w3.lido_contracts.vault_hub,
+            from_block=(10 - 5) * 32,
+            to_block=10 * 32 - 1,
+        )
+
+        service._calculate_vault_fee_components.assert_called_once_with(
+            vault_address=vault_adr,
+            vault_info=vault,
+            vault_total_value=0,
+            vault_events=[],
+            report_interval_seconds=5 * 32 * 12,
+            prev_ref_slot_timestamp=(5 * 32 - 1) * 12,
+            current_ref_slot_timestamp=(10 * 32 - 1) * 12,
             core_apr_ratio=Decimal(0),
             pre_total_pooled_ether=0,
             pre_total_shares=0,

tests/modules/accounting/test_accounting_module.py

@@ -206,7 +206,15 @@ def test_get_slots_elapsed_from_initialize(accounting: Accounting):
     bs = ReferenceBlockStampFactory.build(ref_slot=100)
     slots_elapsed = accounting._get_slots_elapsed_from_last_report(bs)
 
-    assert slots_elapsed == 100 - 32 * 2 + 1
+    # Ref slot of Frame -1.
+    # (initial_epoch - epochs_per_frame) * slots_per_epoch - 1
+    prev_slot = (2 - 1) * 32 - 1  # 31
+    assert slots_elapsed == bs.ref_slot - prev_slot
+
+    accounting.get_frame_config = Mock(return_value=FrameConfigFactory.build(initial_epoch=2, epochs_per_frame=4))
+
+    slots_elapsed = accounting._get_slots_elapsed_from_last_report(bs)
+    assert slots_elapsed == bs.ref_slot
 
 
 @pytest.mark.unit