test: added unchanged dsf checks

Author: Michael

src/test/integration/IntegrationBase.t.sol

@@ -1602,6 +1602,19 @@ abstract contract IntegrationBase is IntegrationDeployer, TypeImporter {
         }
     }
 
+    function assert_Snap_Unchanged_DSF(
+        User staker,
+        IStrategy[] memory strategies,
+        string memory err
+    ) internal {
+        uint[] memory curDSFs = _getDepositScalingFactors(staker, strategies);
+        uint[] memory prevDSFs = _getPrevDepositScalingFactors(staker, strategies);
+
+        for (uint i = 0; i < strategies.length; i++) {
+            assertEq(prevDSFs[i], curDSFs[i], err);
+        }
+    }
+
     /*******************************************************************************
                         SNAPSHOT ASSERTIONS: STRATEGY SHARES
     *******************************************************************************/

src/test/integration/IntegrationChecks.t.sol

@@ -9,6 +9,7 @@ import "src/test/integration/users/User_M2.t.sol";
 /// @notice Contract that provides utility functions to reuse common test blocks & checks
 contract IntegrationCheckUtils is IntegrationBase {
     using ArrayLib for IStrategy[];
+    using ArrayLib for IStrategy;
     using SlashingLib for *;
     using StdStyle for *;
 
@@ -178,7 +179,7 @@ contract IntegrationCheckUtils is IntegrationBase {
 
     function check_Delegation_State(
         User staker, 
-        User operator, 
+        User operator,
         IStrategy[] memory strategies, 
         uint[] memory shares
     ) internal {
@@ -193,6 +194,7 @@ contract IntegrationCheckUtils is IntegrationBase {
         assert_Snap_Expected_Staker_WithdrawableShares_Delegation(staker, operator, strategies, shares, "withdrawable shares should be unchanged within rounding error after delegating");
         uint256[] memory delegatableShares = _getPrevStakerWithdrawableShares(staker, strategies);
         assert_Snap_Added_OperatorShares(operator, strategies, delegatableShares, "operator should have received shares");
+        //assert_Snap_Added_SlashableStake(operator, operatorSet, strategies, delegatableShares, "operator slashable stake should increase");
     }
 
     function check_QueuedWithdrawal_State(
@@ -221,6 +223,19 @@ contract IntegrationCheckUtils is IntegrationBase {
             "check_QueuedWithdrawal_State: failed to remove staker shares");
         assert_Snap_Removed_Staker_WithdrawableShares(staker, strategies, shares,
             "check_QueuedWithdrawal_State: failed to remove staker withdrawable shares");
+        // Check that the dsf is either reset to wad or unchanged
+        for (uint i = 0; i < strategies.length; i++) {
+            // For a full withdrawal, the dsf should be reset to wad
+            if (_getStakerDepositShares(staker, strategies[i].toArray())[0] == 0) {
+                assert_DSF_Reset(staker, strategies[i].toArray(), 
+                    "check_QueuedWithdrawal_State: dsf should be reset to wad");
+            }
+            // For a partial withdrawal, the dsf should not be changed 
+            else {
+                assert_Snap_Unchanged_DSF(staker, strategies[i].toArray(), 
+                    "check_QueuedWithdrawal_State: dsf should not be changed");
+            }
+        }
     }
 
     function check_Undelegate_State(
@@ -257,7 +272,8 @@ contract IntegrationCheckUtils is IntegrationBase {
 
     function check_Redelegate_State(
         User staker, 
-        User operator,
+        User oldOperator,
+        User newOperator,
         IDelegationManagerTypes.Withdrawal[] memory withdrawals,
         bytes32[] memory withdrawalRoots,
         IStrategy[] memory strategies,
@@ -277,12 +293,14 @@ contract IntegrationCheckUtils is IntegrationBase {
             "check_Redelegate_State: stakers withdrawal should now be pending");
         assert_Snap_Added_QueuedWithdrawals(staker, withdrawals,
             "check_Redelegate_State: staker should have increased nonce by withdrawals.length");
-        assert_Snap_Removed_OperatorShares(operator, strategies, stakerDelegatedShares,
+        assert_Snap_Removed_OperatorShares(oldOperator, strategies, stakerDelegatedShares,
             "check_Redelegate_State: failed to remove operator shares");
         assert_Snap_Removed_Staker_DepositShares(staker, strategies, stakerDepositShares,
             "check_Redelegate_State: failed to remove staker shares");
         assert_Snap_RemovedAll_Staker_WithdrawableShares(staker, strategies,
             "check_QueuedWithdrawal_State: failed to remove staker withdrawable shares");
+        assert_Snap_Unchanged_OperatorShares(newOperator,
+            "check_Redelegate_State: new operator shares should not have changed");
     }
 
     /**
@@ -309,6 +327,7 @@ contract IntegrationCheckUtils is IntegrationBase {
 
         assert_Snap_Added_TokenBalances(staker, tokens, expectedTokens, "staker should have received expected tokens");
         assert_Snap_Unchanged_Staker_DepositShares(staker, "staker shares should not have changed");
+        assert_Snap_Unchanged_DSF(staker, strategies, "dsf should not be changed");
         assert_Snap_Removed_StrategyShares(strategies, shares, "strategies should have total shares decremented");
 
         // Checks specific to an operator that the Staker has delegated to
@@ -331,6 +350,7 @@ contract IntegrationCheckUtils is IntegrationBase {
         assert_WithdrawalNotPending(delegationManager.calculateWithdrawalRoot(withdrawal), "staker withdrawal should no longer be pending");
         assert_Snap_Unchanged_TokenBalances(staker, "staker should not have any change in underlying token balances");
         assert_Snap_Added_Staker_DepositShares(staker, strategies, shares, "staker should have received expected shares");
+        assert_Snap_Added_Staker_WithdrawableShares(staker, strategies, shares, "staker should have received expected withdrawable shares");
         assert_Snap_Unchanged_StrategyShares(strategies, "strategies should have total shares unchanged");
 
         // Additional checks or handling for the non-user operator scenario

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

@@ -236,7 +236,7 @@ contract Integration_SlashedEigenpod is IntegrationCheckUtils {
         // Undelegate from an operator
         IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.redelegate(operator2);
         bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals);
-        check_Redelegate_State(staker, operator, withdrawals, withdrawalRoots, strategies, initDepositShares, delegatedShares);
+        check_Redelegate_State(staker, operator, operator2, withdrawals, withdrawalRoots, strategies, initDepositShares, delegatedShares);
 
         // Complete withdrawal as shares
         // Fast forward to when we can complete the withdrawal