Slashing integration tests (#1138)

Co-authored-by: Michael <[email protected]>

Author: eigenmikem

src/test/integration/IntegrationBase.t.sol

@@ -219,6 +219,36 @@ abstract contract IntegrationBase is IntegrationDeployer, TypeImporter {
 
         return result;
     }
+
+    /// @dev Choose a random subset of validators (selects AT LEAST ONE but NOT ALL)
+    function _chooseSubset(uint40[] memory validators) internal returns (uint40[] memory) {
+        require(validators.length >= 2, "Need at least 2 validators to choose subset"); 
+
+        uint40[] memory result = new uint40[](validators.length);
+        uint newLen;
+
+        uint rand = _randUint({ min: 1, max: validators.length ** 2 });
+        for (uint i = 0; i < validators.length; i++) {
+            if (rand >> i & 1 == 1) {
+                result[newLen] = validators[i];
+                newLen++;
+            }
+        }
+
+        // If we picked all, remove one random validator
+        if (newLen == validators.length) {
+            uint indexToRemove = _randUint({ min: 0, max: validators.length - 1 });
+            for (uint i = indexToRemove; i < newLen - 1; i++) {
+                result[i] = result[i + 1];
+            }
+            newLen--;
+        }
+
+        // Update array length
+        assembly { mstore(result, newLen) }
+
+        return result;
+    }
 
     function _getTokenName(IERC20 token) internal view returns (string memory) {
         if (token == NATIVE_ETH) {
@@ -1281,8 +1311,11 @@ abstract contract IntegrationBase is IntegrationDeployer, TypeImporter {
                 uint wadToSlash = slashingParams.wadsToSlash[slashingParams.strategies.indexOf(strat)];
                 slashedShares = prevShares[i].mulWadRoundUp(allocateParams.newMagnitudes[i].mulWadRoundUp(wadToSlash));
             }
+            console.log(prevShares[i]);
+            console.log(slashedShares);
+            console.log(curShares[i]);
 
-            assertApproxEqAbs(prevShares[i] - slashedShares, curShares[i], 1, err);
+            assertApproxEqAbs(prevShares[i] - slashedShares, curShares[i], 1000, err);
         }
     }
 
@@ -2115,42 +2148,18 @@ abstract contract IntegrationBase is IntegrationDeployer, TypeImporter {
 
     function _strategiesAndWadsForFullSlash(
         OperatorSet memory operatorSet
-    ) internal view returns (IStrategy[] memory strategies, uint[] memory wadsToSlash) {
-        // Get list of all strategies in an operator set.
-        strategies = allocationManager.getStrategiesInOperatorSet(operatorSet);
-
-        wadsToSlash = new uint[](strategies.length);
-
-        for (uint i; i < strategies.length; ++i) {
-            wadsToSlash[i] = 1 ether;
-        }
+        ) internal view returns (IStrategy[] memory strategies, uint[] memory wadsToSlash) {
+            // Get list of all strategies in an operator set.
+            strategies = allocationManager.getStrategiesInOperatorSet(operatorSet);
+            
+            wadsToSlash = new uint[](strategies.length);
+            
+            for (uint i; i < strategies.length; ++i) {
+                wadsToSlash[i] = 1 ether;
+            }
 
-        return(strategies.sort(), wadsToSlash);
+            return (strategies.sort(), wadsToSlash);
     }
-
-    function _strategiesAndWadsForRandFullSlash(
-        OperatorSet memory operatorSet
-    ) internal returns (IStrategy[] memory strategies, uint[] memory wadsToSlash) {
-        // Get list of all strategies in an operator set.
-        strategies = allocationManager.getStrategiesInOperatorSet(operatorSet);
-
-        // Randomly select a subset of strategies to slash.
-        uint len = _randUint({ min: 1, max: strategies.length });
-
-        // Update length of strategies array.
-        assembly {
-            mstore(strategies, len)
-        }
-        
-        wadsToSlash = new uint[](len);
-        
-        // Fully slash each selected strategy
-        for (uint i; i < len; ++i) {
-            wadsToSlash[i] = 1 ether;
-        }
-
-        return (strategies.sort(), wadsToSlash);
-    }     
 
     function _randMagnitudes(uint64 sum, uint256 len) internal returns (uint64[] memory magnitudes) {
         magnitudes = new uint64[](len);

src/test/integration/IntegrationChecks.t.sol

@@ -971,6 +971,56 @@ contract IntegrationCheckUtils is IntegrationBase {
         }
     }
 
+    function check_Withdrawal_AsTokens_State_AfterBeaconSlash(
+        User staker,
+        User operator,
+        IDelegationManagerTypes.Withdrawal memory withdrawal,
+        IAllocationManagerTypes.AllocateParams memory allocateParams,
+        IAllocationManagerTypes.SlashingParams memory slashingParams,
+        uint[] memory expectedTokens
+    ) internal {
+        IERC20[] memory tokens = new IERC20[](withdrawal.strategies.length);
+
+        for (uint i; i < withdrawal.strategies.length; i++) {
+            IStrategy strat = withdrawal.strategies[i];
+
+            bool isBeaconChainETHStrategy = strat == beaconChainETHStrategy;
+
+            tokens[i] = isBeaconChainETHStrategy ? NATIVE_ETH : withdrawal.strategies[i].underlyingToken();
+            
+            if (slashingParams.strategies.contains(strat)) {
+                uint wadToSlash = slashingParams.wadsToSlash[slashingParams.strategies.indexOf(strat)];
+
+                expectedTokens[i] -= expectedTokens[i]
+                    .mulWadRoundUp(allocateParams.newMagnitudes[i].mulWadRoundUp(wadToSlash));
+
+                uint256 max = allocationManager.getMaxMagnitude(address(operator), strat);
+
+                withdrawal.scaledShares[i] -= withdrawal.scaledShares[i].calcSlashedAmount(WAD, max);
+
+                // Round down to the nearest gwei for beaconchain ETH strategy.
+                if (isBeaconChainETHStrategy) {
+                    expectedTokens[i] -= expectedTokens[i] % 1 gwei;
+                }
+            }
+        }
+
+        // Common checks
+        assert_WithdrawalNotPending(delegationManager.calculateWithdrawalRoot(withdrawal), "staker withdrawal should no longer be pending");
+        
+        // assert_Snap_Added_TokenBalances(staker, tokens, expectedTokens, "staker should have received expected tokens");
+        assert_Snap_Unchanged_StakerDepositShares(staker, "staker shares should not have changed");
+        assert_Snap_Removed_StrategyShares(withdrawal.strategies, withdrawal.scaledShares, "strategies should have total shares decremented");
+
+        // Checks specific to an operator that the Staker has delegated to
+        if (operator != User(payable(0))) {
+            if (operator != staker) {
+                assert_Snap_Unchanged_TokenBalances(operator, "operator token balances should not have changed");
+            }
+            assert_Snap_Unchanged_OperatorShares(operator, "operator shares should not have changed");
+        }
+    }
+
     function check_Withdrawal_AsShares_State_AfterSlash(
         User staker,
         User operator,

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

@@ -5,41 +5,23 @@ import "src/test/integration/IntegrationChecks.t.sol";
 import "src/test/integration/users/User.t.sol";
 import {console} from "forge-std/console.sol";
 
-contract Integration_Deposit_Delegate_Allocate_Slash_Queue_Redeposit is IntegrationCheckUtils {
+contract Integration_Deposit_Delegate_Allocate_Slash_Queue_Redeposit is IntegrationCheckUtils, IDelegationManagerTypes {
 
-    AVS avs;
-    OperatorSet operatorSet;
-
-    User operator;
-    AllocateParams allocateParams;
-
-    User staker;
-    IStrategy[] strategies;
-    uint[] initTokenBalances;
-    uint[] initDepositShares;
-
-    uint[] numTokensRemaining;
-
-    function _init() internal override {
-        // TODO: Partial deposits don't work when beacon chain eth balance is initialized to < 64 ETH, need to write _newRandomStaker variant that ensures beacon chain ETH balance
-        // greater than or equal to 64
-        _configAssetTypes(HOLDS_LST);
-        _configUserTypes(DEFAULT);
-
-        (staker, strategies, initTokenBalances) = _newRandomStaker();
-        (operator,,) = _newRandomOperator();
-        (avs,) = _newRandomAVS();
-
-        uint256[] memory tokensToDeposit = new uint256[](initTokenBalances.length);
-        numTokensRemaining = new uint256[](initTokenBalances.length);
-        for (uint256 i = 0; i < initTokenBalances.length; i++) {
-            if (strategies[i] == BEACONCHAIN_ETH_STRAT) {
-                tokensToDeposit[i] = initTokenBalances[i];
-                continue;
-            }
-
-            tokensToDeposit[i] = initTokenBalances[i]/2;
-            numTokensRemaining[i] = initTokenBalances[i] - tokensToDeposit[i];
+    function testFuzz_deposit_delegate_allocate_fullSlash_queue_complete_redeposit(
+        uint24 _random
+    ) public {
+        _configRand({_randomSeed: _random, _assetTypes: HOLDS_LST, _userTypes: DEFAULT});
+        _upgradeEigenLayerContracts();
+
+        (User staker, IStrategy[] memory strategies, uint256[] memory tokenBalances) = _newRandomStaker();
+        (User operator,,) = _newRandomOperator();
+        (AVS avs,) = _newRandomAVS();
+
+        uint256[] memory tokensToDeposit = new uint256[](tokenBalances.length);
+        uint256[] memory numTokensRemaining = new uint256[](tokenBalances.length);
+        for (uint256 i = 0; i < tokenBalances.length; i++) {
+                tokensToDeposit[i] = tokenBalances[i]/2;
+                numTokensRemaining[i] = tokenBalances[i] - tokensToDeposit[i];
         }
 
         uint256[] memory shares = _calculateExpectedShares(strategies, tokensToDeposit);
@@ -53,127 +35,63 @@ contract Integration_Deposit_Delegate_Allocate_Slash_Queue_Redeposit is Integrat
         check_Delegation_State(staker, operator, strategies, shares);
 
         // Create operator set and register operator
-        operatorSet = avs.createOperatorSet(strategies);
+        OperatorSet memory operatorSet = avs.createOperatorSet(strategies);
         operator.registerForOperatorSet(operatorSet);
-        check_Registration_State_NoAllocation(operator, operatorSet, allStrats);
 
         // 3. Allocate to operator set
-        allocateParams = _genAllocation_AllAvailable(operator, operatorSet);
-        operator.modifyAllocations(allocateParams);
-        check_IncrAlloc_State_Slashable(operator, allocateParams);
+        IAllocationManagerTypes.AllocateParams memory allocateParams = 
+            operator.modifyAllocations(operatorSet, _maxMagnitudes(operatorSet, operator));
+        
+        assert_Snap_Allocations_Modified(
+            operator,
+            allocateParams,
+            false,
+            "operator allocations should be updated before delay"
+        );
 
         _rollBlocksForCompleteAllocation(operator, operatorSet, strategies);
-    }
-  
-    function testFuzz_fullSlash_queue_complete_redeposit(
-        uint24 _random
-    ) public rand(_random) {
+        
+        assert_Snap_Allocations_Modified(
+            operator,
+            allocateParams,
+            true,
+            "operator allocations should be updated after delay"
+        );
+
         // 4. Fully slash operator
-        SlashingParams memory slashingParams;
+        IAllocationManagerTypes.SlashingParams memory slashingParams;
         {
             (IStrategy[] memory strategiesToSlash, uint256[] memory wadsToSlash) =
                 _strategiesAndWadsForFullSlash(operatorSet);
 
             slashingParams = avs.slashOperator(operator, operatorSet.id, strategiesToSlash, wadsToSlash);
             assert_Snap_Allocations_Slashed(slashingParams, operatorSet, true, "operator allocations should be slashed");
-            assert_Snap_Unchanged_Staker_DepositShares(staker, "staker deposit shares should be unchanged after slashing");
+            assert_Snap_Unchanged_StakerDepositShares(staker, "staker deposit shares should be unchanged after slashing");
             assert_Snap_StakerWithdrawableShares_AfterSlash(staker, allocateParams, slashingParams, "staker deposit shares should be slashed");
         }
 
         // 5. Undelegate from an operator
-        Withdrawal[] memory withdrawals = staker.undelegate();
-        bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals);
-
-        // 6. Complete withdrawal
-        _rollBlocksForCompleteWithdrawals(withdrawals);
-        for (uint256 i = 0; i < withdrawals.length; ++i) {
-            uint256[] memory expectedTokens =
-                _calculateExpectedTokens(withdrawals[i].strategies, withdrawals[i].scaledShares);
-            staker.completeWithdrawalAsTokens(withdrawals[i]);
-            check_Withdrawal_AsTokens_State_AfterSlash(staker, operator, withdrawals[i], allocateParams, slashingParams, expectedTokens);
-        }
-
-        // 7. Redeposit
-        uint[] memory shares = _calculateExpectedShares(strategies, numTokensRemaining);
-        staker.depositIntoEigenlayer(strategies, numTokensRemaining);
-        check_Deposit_State(staker, strategies, shares);
-
-        // Final state checks
-        assert_HasExpectedShares(staker, strategies, shares, "staker should have expected shares after redeposit");
-        assert_NoWithdrawalsPending(withdrawalRoots, "all withdrawals should be removed from pending");      
-    }
-
-    function testFuzz_undelegate_fullSlash_complete_redeposit(
-        uint24 _random
-    ) public rand(_random) {
-        // 4. Undelegate from an operator
-        Withdrawal[] memory withdrawals = staker.undelegate();
+        IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.undelegate();
         bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals);
 
-        // 5. Fully slash operator
-        SlashingParams memory slashingParams;
-        {
-            (IStrategy[] memory strategiesToSlash, uint256[] memory wadsToSlash) =
-                _strategiesAndWadsForFullSlash(operatorSet);
-
-            slashingParams = avs.slashOperator(operator, operatorSet.id, strategiesToSlash, wadsToSlash);
-            assert_Snap_Allocations_Slashed(slashingParams, operatorSet, true, "operator allocations should be slashed");
-            assert_Snap_Unchanged_Staker_DepositShares(staker, "staker deposit shares should be unchanged after slashing");
-            assert_Snap_StakerWithdrawableShares_AfterSlash(staker, allocateParams, slashingParams, "staker deposit shares should be slashed");
-        }
-
         // 6. Complete withdrawal
         _rollBlocksForCompleteWithdrawals(withdrawals);
         for (uint256 i = 0; i < withdrawals.length; ++i) {
             uint256[] memory expectedTokens =
                 _calculateExpectedTokens(withdrawals[i].strategies, withdrawals[i].scaledShares);
+            for (uint256 i = 0; i < expectedTokens.length; i++) {
+            }
             staker.completeWithdrawalAsTokens(withdrawals[i]);
             check_Withdrawal_AsTokens_State_AfterSlash(staker, operator, withdrawals[i], allocateParams, slashingParams, expectedTokens);
         }
 
         // 7. Redeposit
-        uint[] memory shares = _calculateExpectedShares(strategies, numTokensRemaining);
+        shares = _calculateExpectedShares(strategies, numTokensRemaining);
         staker.depositIntoEigenlayer(strategies, numTokensRemaining);
         check_Deposit_State(staker, strategies, shares);
 
         // Final state checks
         assert_HasExpectedShares(staker, strategies, shares, "staker should have expected shares after redeposit");
         assert_NoWithdrawalsPending(withdrawalRoots, "all withdrawals should be removed from pending");      
     }
-
-    function testFuzz_depositFull_fullSlash_undelegate_completeAsShares(
-        uint24 _random
-    ) public rand(_random) {
-        uint[] memory shares = _calculateExpectedShares(strategies, numTokensRemaining);
-        staker.depositIntoEigenlayer(strategies, numTokensRemaining);
-        check_Deposit_State(staker, strategies, shares);
-
-        // 4. Fully slash random proper subset of operators strategies
-        SlashingParams memory slashingParams;
-        {
-            (IStrategy[] memory strategiesToSlash, uint256[] memory wadsToSlash) =
-                _strategiesAndWadsForRandFullSlash(operatorSet);
-            slashingParams = avs.slashOperator(operator, operatorSet.id, strategiesToSlash, wadsToSlash);
-            assert_Snap_Allocations_Slashed(slashingParams, operatorSet, true, "operator allocations should be slashed");
-            assert_Snap_Unchanged_Staker_DepositShares(staker, "staker deposit shares should be unchanged after slashing");
-            assert_Snap_StakerWithdrawableShares_AfterSlash(staker, allocateParams, slashingParams, "staker deposit shares should be slashed");
-        }
-
-        // 5. Undelegate from an operator
-        Withdrawal[] memory withdrawals = staker.undelegate();
-        bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals);
-
-        // 6. Complete withdrawal as shares
-        // Fast forward to when we can complete the withdrawal
-        _rollBlocksForCompleteWithdrawals(withdrawals);
-
-        for (uint256 i = 0; i < withdrawals.length; ++i) {
-            staker.completeWithdrawalAsShares(withdrawals[i]);
-            check_Withdrawal_AsShares_State_AfterSlash(staker, operator, withdrawals[i], allocateParams, slashingParams);
-        }
-
-        // Check final state:
-        assert_HasNoUnderlyingTokenBalance(staker, slashingParams.strategies, "staker not have any underlying tokens");
-        assert_NoWithdrawalsPending(withdrawalRoots, "all withdrawals should be removed from pending");
-    }
 }