Vote #198 Post-DG enact chores

tests/snapshot/test_lido_snapshot.py

@@ -6,7 +6,6 @@
 import pytest
 from brownie import ZERO_ADDRESS, chain, web3, accounts
 from brownie.network.account import Account
-from hexbytes import HexBytes
 from pytest_check import check
 from web3.types import Wei
 
@@ -37,11 +36,6 @@ class Frame(TypedDict):
 
 
 EXPECTED_SNAPSHOT_DIFFS: dict[str, Any] = {
-    # Max external ratio is changed from 3% (300 BP) to 30% (3000 BP) in the upgrade
-    "lido.Lido.lidoLocatorAndMaxExternalRatio": (
-        HexBytes("0x00000000000000000000012cc1d0b3de6792bf6b4b37eccdcc24e45978cfd2eb"),
-        HexBytes("0x000000000000000000000bb8c1d0b3de6792bf6b4b37eccdcc24e45978cfd2eb"),
-    ),
 }
 
 

tests/snapshot/test_node_operators_registry.py

@@ -235,14 +235,7 @@ def assert_snapshot(before, after):
     assert after["node_operators_count"] == before["node_operators_count"]
     assert after["active_node_operators_count"] == before["active_node_operators_count"]
     assert after["total_signing_keys_count"] == before["total_signing_keys_count"]
-
-    # TODO: restore this check after v3-phase2 upgrade is complete
-    # assert after["unused_signing_keys_count"] == before["unused_signing_keys_count"]
-    # Note: deposited validators count can differ due to changes in deposit distribution logic
-    # (e.g., CSM stake share limit increase from 5% to 7.5%), so we don't assert it
-    assert len(after["unused_signing_keys_count"]) == len(before["unused_signing_keys_count"])
-    for i, (before_count, after_count) in enumerate(zip(before["unused_signing_keys_count"], after["unused_signing_keys_count"])):
-        assert almost_eq(before_count, after_count, epsilon=8)
+    assert after["unused_signing_keys_count"] == before["unused_signing_keys_count"]
 
     assert_signing_keys(before, after)
     assert_node_operators(before, after)
@@ -254,10 +247,7 @@ def assert_signing_keys(before, after):
         for sk_before, sk_after in zip(before["signing_keys"][id], after["signing_keys"][id]):
             assert sk_before["key"] == sk_after["key"]
             assert sk_before["depositSignature"] == sk_after["depositSignature"]
-            # TODO: restore this check after v3-phase2 upgrade is complete
-            # Note: 'used' status can differ due to changes in deposit distribution logic during upgrade
-            # (e.g., CSM stake share limit increase from 5% to 7.5%), so we don't assert it
-            # assert sk_before["used"] == sk_after["used"]
+            assert sk_before["used"] == sk_after["used"]
 
 
 def assert_rewards_distribution(before, after):
@@ -267,17 +257,10 @@ def assert_rewards_distribution(before, after):
     for i in range(after["active_node_operators_count"]):
         assert rewards_distribution_before["recipients"][i] == rewards_distribution_after["recipients"][i]
 
-        # TODO: restore this check after v3-phase2 upgrade is complete
-        # Note: Rewards distribution (shares in Wei) can differ significantly due to changes in
-        # deposit distribution logic (CSM stake share limit increase, max external ratio changes).
-        # Shares depend on the number of active validators per operator, which changes after upgrade.
-        # epsilon increased from 200k to 10^15 Wei (0.1% of 1 ETH distribution) to accommodate this
         assert almost_eq(
             rewards_distribution_before["shares"][i],
             rewards_distribution_after["shares"][i],
-            # TODO: restore this check after v3-phase2 upgrade is complete
-            # epsilon=200000,  # estimated divergence is number of deposited validators
-            epsilon=10**15,  # 0.1% of 1 ETH distribution (0.001 ETH per operator max divergence)
+            epsilon=200000,  # estimated divergence is number of deposited validators
         )
         assert not rewards_distribution_after["penalized"][i]
 
@@ -289,26 +272,15 @@ def assert_node_operators(before: Dict[str, ReturnValue], after: Dict[str, Retur
         assert node_operator_before["active"] == node_operator_after["active"]
         assert node_operator_before["name"] == node_operator_after["name"]
         assert node_operator_before["rewardAddress"] == node_operator_after["rewardAddress"]
-
-        # TODO: restore this check after v3-phase2 upgrade is complete
-        # assert node_operator_before["totalDepositedValidators"] == node_operator_after["totalDepositedValidators"]
-        # Note: deposited validators count can differ due to changes in deposit distribution logic
-        # (e.g., CSM stake share limit increase from 5% to 7.5%), so we don't assert it
-        assert almost_eq(node_operator_before["totalDepositedValidators"], node_operator_after["totalDepositedValidators"], epsilon=8)
+        assert node_operator_before["totalDepositedValidators"] == node_operator_after["totalDepositedValidators"]
 
         assert node_operator_before["totalExitedValidators"] == node_operator_after["totalExitedValidators"]
         assert node_operator_before["totalAddedValidators"] == node_operator_after["totalAddedValidators"]
 
         if not node_operator_before["active"]:
             assert node_operator_after["totalVettedValidators"] == node_operator_after["totalDepositedValidators"]
-        # TODO: restore this check after v3-phase2 upgrade is complete
-        # else:
-        #     assert node_operator_before["totalVettedValidators"] == node_operator_after["totalVettedValidators"]
-        # Note: vetted validators count can differ due to changes in deposit distribution logic
-        # (e.g., CSM stake share limit increase from 5% to 7.5%), so we don't assert it
         else:
-            assert almost_eq(node_operator_before["totalVettedValidators"], node_operator_after["totalVettedValidators"], epsilon=8)
-
+            assert node_operator_before["totalVettedValidators"] == node_operator_after["totalVettedValidators"]
 
 
 def almost_eq(a, b, epsilon=0):