feat: move redistribution queue to DM (#4)

* feat: move queue to dm

* chore: manually create withdrawal

* chore: add todo

* chore: update event todo

* wip

* wip

* refactor: comment out `assert_Snap_Increased_BurnableShares`

* fix: `DelegationManagerMock` return value

* refactor: comment out old `burnShares` tests

* chore: make fmt

* refactor: remove random json

---------

Co-authored-by: Yash Patil <40046473+ypatil12@users.noreply.github.com>

Author: 0xClandestine

script/deploy/devnet/deploy_from_scratch.s.sol

@@ -235,7 +235,7 @@ contract DeployFromScratch is Script, Test {
             SEMVER
         );
 
-        strategyManagerImplementation = new StrategyManager(allocationManager, delegation, eigenLayerPauserReg, SEMVER);
+        strategyManagerImplementation = new StrategyManager(delegation, eigenLayerPauserReg, SEMVER);
         avsDirectoryImplementation = new AVSDirectory(delegation, eigenLayerPauserReg, SEMVER);
         eigenPodManagerImplementation =
             new EigenPodManager(ethPOSDeposit, eigenPodBeacon, delegation, eigenLayerPauserReg, SEMVER);

script/deploy/local/deploy_from_scratch.slashing.s.sol

@@ -241,7 +241,7 @@ contract DeployFromScratch is Script, Test {
             MIN_WITHDRAWAL_DELAY,
             SEMVER
         );
-        strategyManagerImplementation = new StrategyManager(allocationManager, delegation, eigenLayerPauserReg, SEMVER);
+        strategyManagerImplementation = new StrategyManager(delegation, eigenLayerPauserReg, SEMVER);
         avsDirectoryImplementation = new AVSDirectory(delegation, eigenLayerPauserReg, SEMVER);
         eigenPodManagerImplementation =
             new EigenPodManager(ethPOSDeposit, eigenPodBeacon, delegation, eigenLayerPauserReg, SEMVER);

script/output/devnet/SLASHING_deploy_from_scratch_deployment_data.json

@@ -400,7 +400,7 @@ contract AllocationManager is
             _updateMaxMagnitude(params.operator, params.strategies[i], info.maxMagnitude);
 
             // 6. Slash operators shares in the DelegationManager
-            delegation.slashOperatorShares({
+            shares[i] = delegation.slashOperatorShares({
                 operator: params.operator,
                 operatorSet: operatorSet,
                 slashId: slashId,

src/contracts/core/AllocationManager.sol

@@ -285,7 +285,7 @@ contract DelegationManager is
         IStrategy strategy,
         uint64 prevMaxMagnitude,
         uint64 newMaxMagnitude
-    ) external onlyAllocationManager nonReentrant {
+    ) external onlyAllocationManager nonReentrant returns (uint256) {
         /// forgefmt: disable-next-item
         uint256 operatorSharesSlashed = SlashingLib.calcSlashedAmount({
             operatorShares: operatorShares[operator][strategy],
@@ -316,6 +316,27 @@ contract DelegationManager is
         emit OperatorSharesSlashed(operator, strategy, totalDepositSharesToBurn);
 
         _getShareManager(strategy).increaseBurnableShares(operatorSet, slashId, strategy, totalDepositSharesToBurn);
+
+        IStrategy[] memory singleStrategy = new IStrategy[](1);
+        uint256[] memory singleDepositShares = new uint256[](1);
+        singleStrategy[0] = strategy;
+        singleDepositShares[0] = totalDepositSharesToBurn;
+
+        Withdrawal memory withdrawal = Withdrawal({
+            staker: address(0), // TODO: pass in redistribution recipient in call
+            delegatedTo: address(this),
+            withdrawer: address(0), // We use address(0) as the withdrawer to special case for allowing anybody to complete the withdrawal
+            nonce: slashId,
+            startBlock: uint32(block.number),
+            strategies: singleStrategy,
+            scaledShares: singleDepositShares
+        });
+
+        emit RedistributionQueued(calculateWithdrawalRoot(withdrawal), withdrawal);
+
+        _addWithdrawalToQueue(withdrawal);
+
+        return totalDepositSharesToBurn;
     }
 
     /**
@@ -519,13 +540,21 @@ contract DelegationManager is
             scaledShares: scaledShares
         });
 
+        bytes32 withdrawalRoot = _addWithdrawalToQueue(withdrawal);
+
+        emit SlashingWithdrawalQueued(withdrawalRoot, withdrawal, withdrawableShares);
+        return withdrawalRoot;
+    }
+
+    function _addWithdrawalToQueue(
+        Withdrawal memory withdrawal
+    ) internal returns (bytes32) {
         bytes32 withdrawalRoot = calculateWithdrawalRoot(withdrawal);
 
         pendingWithdrawals[withdrawalRoot] = true;
         _queuedWithdrawals[withdrawalRoot] = withdrawal;
-        _stakerQueuedWithdrawalRoots[staker].add(withdrawalRoot);
+        _stakerQueuedWithdrawalRoots[withdrawal.staker].add(withdrawalRoot);
 
-        emit SlashingWithdrawalQueued(withdrawalRoot, withdrawal, withdrawableShares);
         return withdrawalRoot;
     }
 
@@ -544,15 +573,22 @@ contract DelegationManager is
         bool receiveAsTokens
     ) internal {
         _checkInputArrayLengths(tokens.length, withdrawal.strategies.length);
-        require(msg.sender == withdrawal.withdrawer, WithdrawerNotCaller());
+        if (withdrawal.delegatedTo == address(this)) {
+            // If this is a redistribution withdrawal // TODO: make this cleaner
+            require(receiveAsTokens, WithdrawerNotCaller());
+        } else {
+            require(msg.sender == withdrawal.withdrawer, WithdrawerNotCaller());
+        }
         bytes32 withdrawalRoot = calculateWithdrawalRoot(withdrawal);
         require(pendingWithdrawals[withdrawalRoot], WithdrawalNotQueued());
 
         uint256[] memory prevSlashingFactors;
         {
             // slashableUntil is block inclusive so we need to check if the current block is strictly greater than the slashableUntil block
             // meaning the withdrawal can be completed.
-            uint32 slashableUntil = withdrawal.startBlock + MIN_WITHDRAWAL_DELAY_BLOCKS;
+            // TODO: update delay blocks for redistribution + EIGEN_REDISTRIBUTION_DELAY_BLOCKS
+            uint32 delayBlocks = withdrawal.delegatedTo == address(this) ? 3.5 days : MIN_WITHDRAWAL_DELAY_BLOCKS;
+            uint32 slashableUntil = withdrawal.startBlock + delayBlocks;
             require(uint32(block.number) > slashableUntil, WithdrawalDelayNotElapsed());
 
             // Given the max magnitudes of the operator the staker was originally delegated to, calculate

src/contracts/core/DelegationManager.sol

@@ -8,7 +8,6 @@ import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
 import "../mixins/SignatureUtilsMixin.sol";
 import "../interfaces/IEigenPodManager.sol";
-import "../libraries/OperatorSetLib.sol";
 import "../permissions/Pausable.sol";
 import "./StrategyManagerStorage.sol";
 
@@ -31,8 +30,6 @@ contract StrategyManager is
 {
     using SlashingLib for *;
     using SafeERC20 for IERC20;
-    using OperatorSetLib for OperatorSet;
-    using EnumerableMap for EnumerableMap.AddressToUintMap;
 
     modifier onlyStrategyWhitelister() {
         require(msg.sender == strategyWhitelister, OnlyStrategyWhitelister());
@@ -55,11 +52,10 @@ contract StrategyManager is
      * @param _delegation The delegation contract of EigenLayer.
      */
     constructor(
-        IAllocationManager _allocationManager,
         IDelegationManager _delegation,
         IPauserRegistry _pauserRegistry,
         string memory _version
-    ) StrategyManagerStorage(_allocationManager, _delegation) Pausable(_pauserRegistry) SignatureUtilsMixin(_version) {
+    ) StrategyManagerStorage(_delegation) Pausable(_pauserRegistry) SignatureUtilsMixin(_version) {
         _disableInitializers();
     }
 
@@ -151,63 +147,23 @@ contract StrategyManager is
         IStrategy strategy,
         uint256 addedSharesToBurn
     ) external onlyDelegationManager nonReentrant {
-        EnumerableMap.AddressToUintMap storage operatorSetBurnableShares =
-            _operatorSetBurnableShares[operatorSet.key()][slashId];
-        (, uint256 currentShares) = operatorSetBurnableShares.tryGet(address(strategy));
-        operatorSetBurnableShares.set(address(strategy), currentShares + addedSharesToBurn);
-
+        // (, uint256 currentShares) = EnumerableMap.tryGet(burnableShares, address(strategy));
+        // EnumerableMap.set(burnableShares, address(strategy), currentShares + addedSharesToBurn);
         emit BurnableSharesIncreased(operatorSet, slashId, strategy, addedSharesToBurn);
     }
 
     /// @inheritdoc IStrategyManager
     function burnShares(
         IStrategy strategy
     ) external nonReentrant {
-        EnumerableMap.AddressToUintMap storage burnableShares = _burnableShares;
-        (, uint256 sharesToBurn) = burnableShares.tryGet(address(strategy));
-        burnableShares.remove(address(strategy));
-
-        // NOTE: We use max values for the operatorSet and slashId to indicate that this is a pre-distribution burn.
-        _burnShares({
-            operatorSet: OperatorSet(address(this), type(uint32).max),
-            slashId: type(uint256).max,
-            strategy: strategy,
-            recipient: DEFAULT_BURN_ADDRESS,
-            sharesToBurn: sharesToBurn
-        });
-    }
-
-    /// @inheritdoc IStrategyManager
-    function burnOrDistributeShares(
-        OperatorSet calldata operatorSet,
-        uint256 slashId,
-        IStrategy strategy
-    ) external nonReentrant {
-        EnumerableMap.AddressToUintMap storage operatorSetBurnableShares =
-            _operatorSetBurnableShares[operatorSet.key()][slashId];
-
-        (, uint256 sharesToBurn) = operatorSetBurnableShares.tryGet(address(strategy));
-
-        address recipient = allocationManager.getRedistributionRecipient(operatorSet);
-
-        _burnOrDistributeShares(operatorSetBurnableShares, operatorSet, strategy, slashId, sharesToBurn, recipient);
-    }
-
-    /// @inheritdoc IStrategyManager
-    function burnOrDistributeShares(OperatorSet calldata operatorSet, uint256 slashId) external nonReentrant {
-        EnumerableMap.AddressToUintMap storage operatorSetBurnableShares =
-            _operatorSetBurnableShares[operatorSet.key()][slashId];
-
-        uint256 totalEntries = operatorSetBurnableShares.length();
+        (, uint256 sharesToBurn) = EnumerableMap.tryGet(burnableShares, address(strategy));
+        EnumerableMap.remove(burnableShares, address(strategy));
+        emit BurnableSharesDecreased(OperatorSet(address(this), 0), 0, strategy, sharesToBurn);
 
-        address recipient = allocationManager.getRedistributionRecipient(operatorSet);
-
-        for (uint256 i = 0; i < totalEntries; ++i) {
-            (address strategy, uint256 sharesToBurn) = operatorSetBurnableShares.at(i);
-
-            _burnOrDistributeShares(
-                operatorSetBurnableShares, operatorSet, IStrategy(strategy), slashId, sharesToBurn, recipient
-            );
+        // Burning acts like withdrawing, except that the destination is to the burn address.
+        // If we have no shares to burn, we don't need to call the strategy.
+        if (sharesToBurn != 0) {
+            strategy.withdraw(DEFAULT_BURN_ADDRESS, strategy.underlyingToken(), sharesToBurn);
         }
     }
 
@@ -348,62 +304,6 @@ contract StrategyManager is
         return userDepositShares;
     }
 
-    /**
-     * @notice Burns `sharesToBurn` shares from `strategy` and sends the underlying tokens to `recipient`.
-     * @param operatorSet The operator set associated with this burn/redistribution.
-     * @param slashId The unique identifier for the slashing event relative to the operator set.
-     * @param strategy The strategy contract from which shares will be burned.
-     * @param recipient The address that will receive the underlying tokens from the burned shares.
-     * @param sharesToBurn The number of shares to burn from the strategy.
-     */
-    function _burnShares(
-        OperatorSet memory operatorSet,
-        uint256 slashId,
-        IStrategy strategy,
-        address recipient,
-        uint256 sharesToBurn
-    ) internal {
-        emit BurnableSharesDecreased(operatorSet, slashId, strategy, recipient, sharesToBurn);
-
-        // Burning acts like withdrawing, except that the destination is to the burn address.
-        // If we have no shares to burn, we don't need to call the strategy.
-        if (sharesToBurn != 0) {
-            strategy.withdraw(recipient, strategy.underlyingToken(), sharesToBurn);
-        }
-    }
-
-    /**
-     * @notice Burns `sharesToBurn` shares from `strategy` and sends the underlying tokens to redistribution recipient or `DEFAULT_BURN_ADDRESS`.
-     * @param ptr The pointer to the operator set burnable shares map.
-     * @param operatorSet The operator set associated with this burn/redistribution.
-     * @param slashId The unique identifier for the slashing event relative to the operator set.
-     * @param strategy The strategy contract from which shares will be burned.
-     * @param sharesToBurn The number of shares to burn from the strategy.
-     */
-    function _burnOrDistributeShares(
-        EnumerableMap.AddressToUintMap storage ptr,
-        OperatorSet calldata operatorSet,
-        IStrategy strategy,
-        uint256 slashId,
-        uint256 sharesToBurn,
-        address recipient
-    ) internal {
-        require(
-            block.timestamp >= allocationManager.getBurnOrRedistributionBlock(operatorSet, strategy, slashId),
-            BurnOrRedistributionDelayNotElapsed()
-        );
-
-        ptr.remove(address(strategy));
-
-        _burnShares({
-            operatorSet: operatorSet,
-            slashId: slashId,
-            strategy: IStrategy(strategy),
-            recipient: recipient,
-            sharesToBurn: sharesToBurn
-        });
-    }
-
     /**
      * @notice Removes `strategy` from `staker`'s dynamic array of strategies, i.e. from `stakerStrategyList[staker]`
      * @param staker The user whose array will have an entry removed
@@ -493,48 +393,22 @@ contract StrategyManager is
     /// @inheritdoc IStrategyManager
     function getBurnableShares(
         IStrategy strategy
-    ) external view returns (uint256 shares) {
-        (, shares) = _burnableShares.tryGet(address(strategy));
-    }
-
-    /// @inheritdoc IStrategyManager
-    function getOperatorSetBurnableShares(
-        OperatorSet calldata operatorSet,
-        uint256 slashId,
-        IStrategy strategy
-    ) external view returns (uint256 shares) {
-        (, shares) = _operatorSetBurnableShares[operatorSet.key()][slashId].tryGet(address(strategy));
+    ) external view returns (uint256) {
+        (, uint256 shares) = EnumerableMap.tryGet(burnableShares, address(strategy));
+        return shares;
     }
 
     /// @inheritdoc IStrategyManager
     function getStrategiesWithBurnableShares() external view returns (address[] memory, uint256[] memory) {
-        EnumerableMap.AddressToUintMap storage burnableShares = _burnableShares;
-        uint256 totalEntries = burnableShares.length();
-
-        address[] memory strategies = new address[](totalEntries);
-        uint256[] memory shares = new uint256[](totalEntries);
-
-        for (uint256 i = 0; i < totalEntries; ++i) {
-            (strategies[i], shares[i]) = burnableShares.at(i);
-        }
-
-        return (strategies, shares);
-    }
-
-    /// @inheritdoc IStrategyManager
-    function getOperatorSetStrategiesWithBurnableShares(
-        OperatorSet calldata operatorSet,
-        uint256 slashId
-    ) external view returns (address[] memory, uint256[] memory) {
-        EnumerableMap.AddressToUintMap storage operatorSetBurnableShares =
-            _operatorSetBurnableShares[operatorSet.key()][slashId];
-        uint256 totalEntries = operatorSetBurnableShares.length();
+        uint256 totalEntries = EnumerableMap.length(burnableShares);
 
         address[] memory strategies = new address[](totalEntries);
         uint256[] memory shares = new uint256[](totalEntries);
 
-        for (uint256 i = 0; i < totalEntries; ++i) {
-            (strategies[i], shares[i]) = operatorSetBurnableShares.at(i);
+        for (uint256 i = 0; i < totalEntries; i++) {
+            (address strategy, uint256 shareAmount) = EnumerableMap.at(burnableShares, i);
+            strategies[i] = strategy;
+            shares[i] = shareAmount;
         }
 
         return (strategies, shares);