test: passing redistribution upgrade test

Author: ypatil12

src/test/integration/IntegrationBase.t.sol

@@ -13,7 +13,6 @@ import "src/test/integration/TypeImporter.t.sol";
 import "src/test/integration/IntegrationDeployer.t.sol";
 import "src/test/integration/TimeMachine.t.sol";
 import "src/test/integration/users/User.t.sol";
-import "src/test/integration/users/User_M1.t.sol";
 
 abstract contract IntegrationBase is IntegrationDeployer, TypeImporter {
     using StdStyle for *;

src/test/integration/IntegrationChecks.t.sol

@@ -3,7 +3,6 @@ pragma solidity ^0.8.27;
 
 import "src/test/integration/IntegrationBase.t.sol";
 import "src/test/integration/users/User.t.sol";
-import "src/test/integration/users/User_M1.t.sol";
 
 /// @notice Contract that provides utility functions to reuse common test blocks & checks
 contract IntegrationCheckUtils is IntegrationBase {

src/test/integration/deprecatedInterfaces/mainnet/AllocationManager.sol

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.27;
+
+import "src/contracts/interfaces/IStrategy.sol";
+
+/** 
+ * @notice Interface of the allocationManager prior to redistribution. 
+ * @dev The interface remains the exact same, except `SlashOperator` does not return the slashID or shares
+ * @dev This interface is the minimal possibl interface needed for the redistribution upgrade test
+ */
+interface IAllocationManager_PreRedistribution {
+    
+    /**
+     * @notice Struct containing parameters to slashing
+     * @param operator the address to slash
+     * @param operatorSetId the ID of the operatorSet the operator is being slashed on behalf of
+     * @param strategies the set of strategies to slash
+     * @param wadsToSlash the parts in 1e18 to slash, this will be proportional to the operator's
+     * slashable stake allocation for the operatorSet
+     * @param description the description of the slashing provided by the AVS for legibility
+     */
+    struct SlashingParams {
+        address operator;
+        uint32 operatorSetId;
+        IStrategy[] strategies;
+        uint256[] wadsToSlash;
+        string description;
+    }
+
+    /**
+     * @notice Called by an AVS to slash an operator in a given operator set. The operator must be registered
+     * and have slashable stake allocated to the operator set.
+     *
+     * @param avs The AVS address initiating the slash.
+     * @param params The slashing parameters, containing:
+     *  - operator: The operator to slash.
+     *  - operatorSetId: The ID of the operator set the operator is being slashed from.
+     *  - strategies: Array of strategies to slash allocations from (must be in ascending order).
+     *  - wadsToSlash: Array of proportions to slash from each strategy (must be between 0 and 1e18).
+     *  - description: Description of why the operator was slashed.
+     *
+     * @dev For each strategy:
+     *      1. Reduces the operator's current allocation magnitude by wadToSlash proportion.
+     *      2. Reduces the strategy's max and encumbered magnitudes proportionally.
+     *      3. If there is a pending deallocation, reduces it proportionally.
+     *      4. Updates the operator's shares in the DelegationManager.
+     *
+     * @dev Small slashing amounts may not result in actual token burns due to
+     *      rounding, which will result in small amounts of tokens locked in the contract
+     *      rather than fully burning through the burn mechanism.
+     */
+    function slashOperator(address avs, SlashingParams calldata params) external;
+}

src/test/integration/tests/upgrade/Redistribution.t.sol

@@ -52,7 +52,7 @@ contract Integration_Upgrade_Redistribution_Base is UpgradeTest {
 
         // 6. Operator is randomly slashed by the operatorSet
         slashParams = _genSlashing_Rand(operator, operatorSet);
-        avs.slashOperator(slashParams);
+        avs.slashOperator_PreRedistribution(slashParams);
     }
 }
 

src/test/integration/users/AVS.t.sol

@@ -14,6 +14,7 @@ import "src/test/utils/Logger.t.sol";
 
 import "src/test/utils/ArrayLib.sol";
 import "src/contracts/interfaces/IAVSRegistrar.sol";
+import "src/test/integration/deprecatedInterfaces/mainnet/AllocationManager.sol";
 
 interface IAVSDeployer {
     function delegationManager() external view returns (DelegationManager);
@@ -134,10 +135,50 @@ contract AVS is Logger, IAllocationManagerTypes, IAVSRegistrar {
         }
 
         _tryPrankAppointee_AllocationManager(IAllocationManager.slashOperator.selector);
+
         allocationManager.slashOperator(address(this), params);
         print.gasUsed();
     }
 
+    /// @notice Slash operator prior to redistribution.
+    /// @dev This is ONLY used by the redistribution upgrade test.
+    function slashOperator_PreRedistribution(SlashingParams memory params) public createSnapshot {
+
+        IAllocationManager_PreRedistribution.SlashingParams memory slashParams = IAllocationManager_PreRedistribution.SlashingParams({
+            operator: params.operator,
+            operatorSetId: params.operatorSetId,
+            strategies: params.strategies,
+            wadsToSlash: params.wadsToSlash,
+            description: params.description
+        });
+
+        for (uint i; i < params.strategies.length; ++i) {
+            string memory strategyName = params.strategies[i] == beaconChainETHStrategy
+                ? "Native ETH"
+                : IERC20Metadata(address(params.strategies[i].underlyingToken())).name();
+
+            print.method(
+                "slashOperator",
+                string.concat(
+                    "{operator: ",
+                    User(payable(params.operator)).NAME_COLORED(),
+                    ", operatorSetId: ",
+                    cheats.toString(params.operatorSetId),
+                    ", strategy: ",
+                    strategyName,
+                    ", wadToSlash: ",
+                    params.wadsToSlash[i].asWad(),
+                    "}"
+                )
+            );
+        }
+
+        _tryPrankAppointee_AllocationManager(IAllocationManager.slashOperator.selector);
+        
+        IAllocationManager_PreRedistribution(address(allocationManager)).slashOperator(address(this), slashParams);
+        print.gasUsed();
+    }
+
     function slashOperator(User operator, uint32 operatorSetId, IStrategy[] memory strategies, uint[] memory wadsToSlash)
         public
         createSnapshot