Slashing integration tests (#1003)

* Validate that users who are slashed fully can redeposit once undelegated

* removing arraylib use

* test for updating eigenpod state -> slash/undelegate

* removing unnecessary logging function

* fixing strategy set

* beacon chain tests in progress

---------

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

Author: 2 people

src/test/integration/IntegrationBase.t.sol

@@ -186,6 +186,36 @@ abstract contract IntegrationBase is IntegrationDeployer {
 
         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) {
@@ -561,8 +591,11 @@ abstract contract IntegrationBase is IntegrationDeployer {
                 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);
         }
     }
 
@@ -1133,6 +1166,21 @@ abstract contract IntegrationBase is IntegrationDeployer {
 
         return (strategies.sort(), wadsToSlash);
     }
+
+    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;
+            }
+
+            return (strategies.sort(), wadsToSlash);
+    }
 
     function _randMagnitudes(uint64 sum, uint256 len) internal returns (uint64[] memory magnitudes) {
         magnitudes = new uint64[](len);
@@ -1151,6 +1199,18 @@ abstract contract IntegrationBase is IntegrationDeployer {
         }
     }
 
+    function _maxMagnitudes(OperatorSet memory operatorSet, User operator) internal view returns (uint64[] memory magnitudes) {
+        IStrategy[] memory strategies = allocationManager.getStrategiesInOperatorSet(operatorSet);
+        uint256 len = strategies.length;
+        magnitudes = new uint64[](len);
+
+        if (len == 0) return magnitudes;
+
+        for (uint256 i; i < len; ++i) {
+            magnitudes[i] = allocationManager.getMaxMagnitude(address(operator), strategies[i]);
+        }
+    }
+
     function _randWithdrawal(
         IStrategy[] memory strategies, 
         uint[] memory shares

src/test/integration/IntegrationChecks.t.sol

@@ -390,6 +390,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

@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.27;
+
+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, IDelegationManagerTypes {
+
+    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);
+
+        // 1. Deposit Into Strategies
+        staker.depositIntoEigenlayer(strategies, tokensToDeposit);
+        check_Deposit_State_PartialDeposit(staker, strategies, shares, numTokensRemaining);
+
+        // 2. Delegate to operator
+        staker.delegateTo(operator);
+        check_Delegation_State(staker, operator, strategies, shares);
+
+        // Create operator set and register operator
+        OperatorSet memory operatorSet = avs.createOperatorSet(strategies);
+        operator.registerForOperatorSet(operatorSet);
+
+        // 3. Allocate to operator set
+        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);
+        
+        assert_Snap_Allocations_Modified(
+            operator,
+            allocateParams,
+            true,
+            "operator allocations should be updated after delay"
+        );
+
+        // 4. Fully slash operator
+        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_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
+        IDelegationManagerTypes.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);
+            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
+        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");      
+    }
+}