test(wip): start on deregistration invariants

Author: wadealexc

src/test/integration/IntegrationBase.t.sol

@@ -472,6 +472,18 @@ abstract contract IntegrationBase is IntegrationDeployer {
         assertFalse(prevIsMemberOfSet, err);
         assertTrue(curIsMemberOfSet, err);
     }
+
+    function assert_Snap_Became_Deregistered(
+        User operator,
+        OperatorSet memory operatorSet,
+        string memory err
+    ) internal {
+        bool curIsMemberOfSet = _getIsMemberOfSet(operator, operatorSet);
+        bool prevIsMemberOfSet = _getPrevIsMemberOfSet(operator, operatorSet);
+
+        assertTrue(prevIsMemberOfSet, err);
+        assertFalse(curIsMemberOfSet, err);
+    }
 
     function assert_Snap_Became_Slashable(
         User operator,
@@ -485,6 +497,18 @@ abstract contract IntegrationBase is IntegrationDeployer {
         assertTrue(curIsSlashable, err);
     }
 
+    function assert_Snap_Remains_Slashable(
+        User operator,
+        OperatorSet memory operatorSet,
+        string memory err
+    ) internal {
+        bool curIsSlashable = _getIsSlashable(operator, operatorSet);
+        bool prevIsSlashable = _getPrevIsSlashable(operator, operatorSet);
+
+        assertTrue(prevIsSlashable, err);
+        assertTrue(curIsSlashable, err);
+    }
+
     /// @dev Assert that we created a pending allocation with a POSITIVE pendingDiff
     function assert_Snap_Created_PendingIncrease(
         User operator,
@@ -583,9 +607,8 @@ abstract contract IntegrationBase is IntegrationDeployer {
         OperatorSet[] memory prevAllocatedSets = _getPrevAllocatedSets(operator);
 
         assertEq(curAllocatedSets.length, prevAllocatedSets.length + 1, err);
-        OperatorSet memory addedSet = curAllocatedSets[curAllocatedSets.length - 1];
-        assertEq(addedSet.avs, operatorSet.avs, err);
-        assertEq(addedSet.id, operatorSet.id, err);
+        assertFalse(prevAllocatedSets.contains(operatorSet), err);
+        assertTrue(curAllocatedSets.contains(operatorSet), err);
     }
 
     function assert_Snap_Unchanged_AllocatedSets(
@@ -607,9 +630,8 @@ abstract contract IntegrationBase is IntegrationDeployer {
         OperatorSet[] memory prevAllocatedSets = _getPrevAllocatedSets(operator);
 
         assertEq(curAllocatedSets.length + 1, prevAllocatedSets.length, err);
-        OperatorSet memory removedSet = prevAllocatedSets[prevAllocatedSets.length - 1];
-        assertEq(removedSet.avs, operatorSet.avs, err);
-        assertEq(removedSet.id, operatorSet.id, err);
+        assertTrue(prevAllocatedSets.contains(operatorSet), err);
+        assertFalse(curAllocatedSets.contains(operatorSet), err);
     }
 
     function assert_Snap_Added_RegisteredSet(
@@ -621,9 +643,21 @@ abstract contract IntegrationBase is IntegrationDeployer {
         OperatorSet[] memory prevRegisteredSets = _getPrevRegisteredSets(operator);
 
         assertEq(curRegisteredSets.length, prevRegisteredSets.length + 1, err);
-        OperatorSet memory addedSet = curRegisteredSets[curRegisteredSets.length - 1];
-        assertEq(addedSet.avs, operatorSet.avs, err);
-        assertEq(addedSet.id, operatorSet.id, err);
+        assertFalse(prevRegisteredSets.contains(operatorSet), err);
+        assertTrue(curRegisteredSets.contains(operatorSet), err);
+    }
+
+    function assert_Snap_Removed_RegisteredSet(
+        User operator,
+        OperatorSet memory operatorSet,
+        string memory err
+    ) internal {
+        OperatorSet[] memory curRegisteredSets = _getRegisteredSets(operator);
+        OperatorSet[] memory prevRegisteredSets = _getPrevRegisteredSets(operator);
+
+        assertEq(curRegisteredSets.length + 1, prevRegisteredSets.length, err);
+        assertTrue(prevRegisteredSets.contains(operatorSet), err);
+        assertFalse(curRegisteredSets.contains(operatorSet), err);
     }
 
     function assert_Snap_Added_MemberOfSet(
@@ -635,8 +669,21 @@ abstract contract IntegrationBase is IntegrationDeployer {
         address[] memory prevOperators = _getPrevMembers(operatorSet);
 
         assertEq(curOperators.length, prevOperators.length + 1, err);
-        address memberAdded = curOperators[curOperators.length - 1];
-        assertEq(memberAdded, address(operator), err);
+        assertFalse(prevOperators.contains(address(operator)), err);
+        assertTrue(curOperators.contains(address(operator)), err);
+    }
+
+    function assert_Snap_Removed_MemberOfSet(
+        User operator,
+        OperatorSet memory operatorSet,
+        string memory err
+    ) internal {
+        address[] memory curOperators = _getMembers(operatorSet);
+        address[] memory prevOperators = _getPrevMembers(operatorSet);
+
+        assertEq(curOperators.length + 1, prevOperators.length, err);
+        assertTrue(prevOperators.contains(address(operator)), err);
+        assertFalse(curOperators.contains(address(operator)), err);
     }
 
     function assert_Snap_StakeBecameSlashable(

src/test/integration/IntegrationChecks.t.sol

@@ -329,10 +329,12 @@ contract IntegrationCheckUtils is IntegrationBase {
     }
 
     /*******************************************************************************
-                                 ALLOCATION MANAGER CHECKS
+                                 ALM - REGISTRATION
     *******************************************************************************/
 
-    /// @dev Basic invariants that should hold after EVERY call to `registerForOperatorSet`
+    /// @dev Basic invariants that should hold after EVERY call to `registerForOperatorSets`
+    /// NOTE: These are only slightly modified from check_Base_Deregistration_State
+    /// If you add invariants here, consider adding them there (and vice-versa)
     function check_Base_Registration_State(
         User operator,
         OperatorSet memory operatorSet
@@ -447,6 +449,42 @@ contract IntegrationCheckUtils is IntegrationBase {
         _rollBackward_AllocationDelay(operator);
     }
 
+    /*******************************************************************************
+                                 ALM - DEREGISTRATION
+    *******************************************************************************/
+
+    /// @dev Basic invariants that should hold after EVERY call to `deregisterFromOperatorSets`
+    /// NOTE: These are only slightly modified from check_Base_Registration_State
+    /// If you add invariants here, consider adding them there (and vice-versa)
+    function check_Base_Deregistration_State(
+        User operator,
+        OperatorSet memory operatorSet
+    ) internal {
+        // Global invariant
+        assert_MaxMagsEqualMaxMagsAtCurrentBlock(operator, allStrats, "max magnitudes should equal upperlookup at current block");
+
+        // Deregistration SHOULD remove the operator as a member of the set
+        assert_Snap_Became_Deregistered(operator, operatorSet, "operator should have been registered before, and is now deregistered");
+        assert_Snap_Removed_RegisteredSet(operator, operatorSet, "should have removed operator set from list of registered sets");
+        assert_Snap_Removed_MemberOfSet(operator, operatorSet, "should have removed operator from list of set members");
+
+        // Deregistration should NOT change slashability, magnitude, allocations, or allocated sets
+        assert_Snap_Remains_Slashable(operator, operatorSet, "operator should have been slashable already, and should still be slashable");
+        assert_Snap_Unchanged_AllocatedSets(operator, "should not have updated allocated sets");
+        assert_Snap_Unchanged_AllocatedStrats(operator, operatorSet, "should not have updated allocated strategies");
+        assert_Snap_Unchanged_MaxMagnitude(operator, allStrats, "should not have updated max magnitudes in any way");
+        assert_Snap_Unchanged_AllocatedStake(operator, operatorSet, allStrats, "should not have updated allocated stake in any way");
+        assert_Snap_Unchanged_StrategyAllocations(operator, operatorSet, allStrats, "should not have updated any individual allocations");
+        assert_Snap_Unchanged_EncumberedMagnitude(operator, allStrats, "should not have updated encumbered magnitude");
+        assert_Snap_Unchanged_AllocatableMagnitude(operator, allStrats, "should not have updated allocatable magnitude");
+
+        // TODO - once the deallocation delay passes, check again?
+    }
+
+    /*******************************************************************************
+                                 ALM - ALLOCATION
+    *******************************************************************************/
+
     /// @dev NOTE - this is for basic ALLOCATION invariants, NOT DEALLOCATION
     function check_Base_Allocation_State(
         User operator,

src/test/integration/tests/SlashingWithdrawals.t.sol

@@ -271,6 +271,7 @@ contract Integration_SlashingWithdrawals is IntegrationCheckUtils {
     ) public rand(_random) {
         // 4. Deregister.
         operator.deregisterFromOperatorSet(operatorSet);
+        check_Base_Deregistration_State(operator, operatorSet);
 
         // 5. Slash operator
         IAllocationManagerTypes.SlashingParams memory slashingParams;