test: remove unneeded logic from integration test setup (#1023)

Author: wadealexc

src/test/integration/IntegrationBase.t.sol

@@ -148,21 +148,17 @@ abstract contract IntegrationBase is IntegrationDeployer {
             emit log("_upgradeEigenLayerContracts: upgrading mainnet to slashing");
             _upgradeMainnetContracts();
 
+            // Unpause EigenPodManager
+            cheats.prank(eigenLayerPauserReg.unpauser());
+            eigenPodManager.unpause(0);
+
             // Bump block.timestamp forward to allow verifyWC proofs for migrated pods
             emit log("advancing block time to start of next epoch:");
 
             beaconChain.advanceEpoch_NoRewards();
 
             emit log("======");
 
-            isUpgraded = true;
-            emit log("_upgradeEigenLayerContracts: slashing upgrade complete");
-        } else if (forkType == HOLESKY) {
-            require(!isUpgraded, "_upgradeEigenLayerContracts: already performed slashing upgrade");
-
-            emit log("_upgradeEigenLayerContracts: upgrading holesky to slashing");
-            _upgradeHoleskyContracts();
-
             isUpgraded = true;
             emit log("_upgradeEigenLayerContracts: slashing upgrade complete");
         }

src/test/integration/IntegrationDeployer.t.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.27;
+
+import "src/contracts/interfaces/IAllocationManager.sol";
+import "src/contracts/interfaces/IAVSDirectory.sol";
+import "src/contracts/interfaces/IDelegationManager.sol";
+import "src/contracts/interfaces/IEigenPod.sol";
+import "src/contracts/interfaces/IEigenPodManager.sol";
+import "src/contracts/interfaces/IStrategyManager.sol";
+
+
+/// @dev A master interface contract that imports types defined in our
+/// contract interfaces so they can be used without needing to refer to
+/// the interface, e.g:
+///
+/// `AllocateParams memory params;`
+/// vs
+/// `IAllocationManagerTypes.AllocateParams memory params;`
+interface TypeImporter is 
+    IAllocationManagerTypes,
+    IAVSDirectoryTypes,
+    IDelegationManagerTypes,
+    IEigenPodManagerTypes,
+    IEigenPodTypes
+{
+}

src/test/integration/TypeImporter.t.sol

@@ -7,6 +7,7 @@ import "src/contracts/libraries/BeaconChainProofs.sol";
 import "src/contracts/libraries/Merkle.sol";
 import "src/contracts/pods/EigenPodManager.sol";
 
+import "src/test/mocks/ETHDepositMock.sol";
 import "src/test/integration/mocks/EIP_4788_Oracle_Mock.t.sol";
 import "src/test/utils/Logger.t.sol";
 
@@ -93,6 +94,7 @@ contract BeaconChainMock is Logger {
     uint64 public nextTimestamp;
 
     EigenPodManager eigenPodManager;
+    IETHPOSDeposit constant DEPOSIT_CONTRACT = IETHPOSDeposit(0x00000000219ab540356cBB839Cbe05303d7705Fa);
     EIP_4788_Oracle_Mock constant EIP_4788_ORACLE = EIP_4788_Oracle_Mock(0x000F3df6D732807Ef1319fB7B8bB8522d0Beac02);
 
     /**
@@ -140,6 +142,7 @@ contract BeaconChainMock is Logger {
         eigenPodManager = _eigenPodManager;
 
         // Create mock 4788 oracle
+        cheats.etch(address(DEPOSIT_CONTRACT), type(ETHPOSDepositMock).runtimeCode);
         cheats.etch(address(EIP_4788_ORACLE), type(EIP_4788_Oracle_Mock).runtimeCode);
 
         // Calculate nodes of empty merkle tree

src/test/integration/mocks/BeaconChainMock.t.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.27;
+
+import "src/test/integration/UpgradeTest.t.sol";
+
+contract Integration_Upgrade_Deposit_Delegate_Allocate is UpgradeTest {
+
+    function testFuzz_deposit_delegate_upgrade_allocate(uint24 _random) public rand(_random) {
+        (User staker, IStrategy[] memory strategies, uint256[] memory tokenBalances) = _newRandomStaker();
+        (User operator,,) = _newRandomOperator();
+
+        // Pre-upgrade:
+        // 1. Create staker and operator with assets, then deposit into EigenLayer
+        // 2. Delegate to operator
+        staker.depositIntoEigenlayer(strategies, tokenBalances);
+        staker.delegateTo(operator);
+
+        // Upgrade to slashing release
+        _upgradeEigenLayerContracts();
+        (AVS avs,) = _newRandomAVS();
+
+        // 3. Set allocation delay for operator
+        operator.setAllocationDelay(1);
+        rollForward({blocks: ALLOCATION_CONFIGURATION_DELAY + 1});
+
+        // 4. Create an operator set and register an operator.
+        OperatorSet memory operatorSet = avs.createOperatorSet(strategies);
+        operator.registerForOperatorSet(operatorSet);
+        check_Registration_State_NoAllocation(operator, operatorSet, allStrats);
+
+        // 5. Allocate to operator set.
+        AllocateParams memory allocateParams = AllocateParams({
+            operatorSet: operatorSet,
+            strategies: strategies,
+            newMagnitudes: _randMagnitudes({sum: 1 ether, len: strategies.length})
+        });
+        operator.modifyAllocations(allocateParams);
+        check_IncrAlloc_State_Slashable(operator, allocateParams);
+    }
+}

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

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.27;
+
+import "src/test/integration/UpgradeTest.t.sol";
+
+contract Integration_Upgrade_EigenPod_Slashing_Migration is UpgradeTest, EigenPodPausingConstants {
+    
+    function _init() internal override {
+        _configAssetTypes(HOLDS_ETH);
+        _configUserTypes(DEFAULT);   
+    }
+
+    /**
+     * @dev Assumes that the Prooftra and slashing upgrade occur at the same time
+     * 1. Verify validators' withdrawal credentials
+     *    -- earn rewards on beacon chain (withdrawn to pod)
+     * 2. Start a checkpoint
+     * 3. Pause starting checkpoints
+     * 4. Complete in progress checkpoint
+     * 5. Upgrade EigenPod contracts
+     * 6. Exit subset of Validators 
+     */
+    function test_upgrade_eigenpod_migration(uint24 _rand) public rand(_rand) {
+        // Initialize state
+        (User staker, ,) = _newRandomStaker();    
+
+        (uint40[] memory validators, ,) = staker.startValidators();
+        beaconChain.advanceEpoch_NoRewards(); 
+
+        // 1. Verify validators' withdrawal credentials
+        staker.verifyWithdrawalCredentials(validators);
+
+        // Advance epoch, generating consensus rewards and withdrawing anything over 32 ETH
+        beaconChain.advanceEpoch();
+
+        // 2. Start a checkpoint
+        staker.startCheckpoint();
+
+        // 3. Pause checkpoint starting
+        cheats.prank(pauserMultisig);
+        eigenPodManager.pause(2 ** PAUSED_START_CHECKPOINT);
+        cheats.expectRevert("EigenPod.onlyWhenNotPaused: index is paused in EigenPodManager");
+        staker.startCheckpoint();
+
+        // 4. Complete in progress checkpoint
+        staker.completeCheckpoint();
+
+        // 5. Upgrade Contracts for slashing      
+        _upgradeEigenLayerContracts();
+
+        // Unpause EigenPodManager
+        cheats.prank(eigenLayerPauserReg.unpauser());
+        eigenPodManager.unpause(0);
+
+        // 6. Exit validators
+        // Fully exit one or more validators and advance epoch without generating rewards
+        uint40[] memory subset = _choose(validators);
+        uint64 exitedBalanceGwei = staker.exitValidators(subset);
+        beaconChain.advanceEpoch_NoRewards();
+
+        staker.startCheckpoint();
+        check_StartCheckpoint_WithPodBalance_State(staker, exitedBalanceGwei);
+
+        // staker.completeCheckpoint();
+        // check_CompleteCheckpoint_WithExits_State(staker, subset, exitedBalanceGwei);
+    }
+}

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

@@ -0,0 +1,129 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.27;
+
+import "src/test/integration/UpgradeTest.t.sol";
+contract Integration_Upgrade_Pectra is UpgradeTest, EigenPodPausingConstants {
+    function _init() internal override {
+        _configAssetTypes(HOLDS_ETH);
+        _configUserTypes(DEFAULT);
+    }
+
+    function test_Upgrade_VerifyWC_StartCP_CompleteCP(uint24 _rand) public rand(_rand) {
+        // 1. Pause, Fork, and Upgrade
+        _pauseForkAndUpgrade();
+
+        // 2. Set Pectra Fork Timestamp & unpause
+        _setTimestampAndUnpause();
+
+        // 3. Initialize Staker
+        (User staker, ,) = _newRandomStaker();
+        (uint40[] memory validators, uint64 beaconBalanceGwei, ) = staker.startValidators();
+        beaconChain.advanceEpoch_NoRewards();
+
+        // 4. Verify Withdrawal Credentials
+        staker.verifyWithdrawalCredentials(validators);
+        check_VerifyWC_State(staker, validators, beaconBalanceGwei);
+
+        // 4. Start Checkpoint
+        staker.startCheckpoint();
+        check_StartCheckpoint_State(staker);
+
+        // 5. Complete Checkpoint
+        staker.completeCheckpoint();
+        check_CompleteCheckpoint_State(staker);
+    }        
+
+    function test_VerifyWC_StartCP_Fork_CompleteCP(uint24 _rand) public rand(_rand) {
+        // Initialize state
+        (User staker, ,) = _newRandomStaker();    
+        (uint40[] memory validators, ,) = staker.startValidators();
+        beaconChain.advanceEpoch_NoRewards(); 
+
+        // 1. Verify validators' withdrawal credentials
+        staker.verifyWithdrawalCredentials(validators);
+
+        // 2. Start a checkpoint
+        staker.startCheckpoint();
+
+        // 3. Pause, Fork, and Upgrade
+        _pauseForkAndUpgrade();
+
+        // 4. Set Pectra Fork Timestamp & unpause
+        _setTimestampAndUnpause();
+
+        // 5. Complete in progress checkpoint
+        staker.completeCheckpoint();
+        check_CompleteCheckpoint_State(staker);
+    }
+
+    function test_VerifyWC_Fork_EarnToPod_StartCP_CompleteCP(uint24 _rand) public rand(_rand) {
+        // Initialize state
+        (User staker, ,) = _newRandomStaker();    
+        (uint40[] memory validators, ,) = staker.startValidators();
+        beaconChain.advanceEpoch_NoRewards(); 
+
+        // 1. Verify validators' withdrawal credentials
+        staker.verifyWithdrawalCredentials(validators);
+
+        // 2. Pause, Fork, and Upgrade
+        _pauseForkAndUpgrade();
+
+        // 3. Set timestamp and unpause
+        _setTimestampAndUnpause();
+
+        // 4. Advance epoch, generating consensus rewards and withdrawing anything over Max EB
+        // Not: Nothing is withdrawn because all validators were created with 32 ETH
+        beaconChain.advanceEpoch();
+        uint64 expectedEarnedGwei = uint64(validators.length) * beaconChain.CONSENSUS_REWARD_AMOUNT_GWEI();
+
+        // 5. Start a checkpoint
+        staker.startCheckpoint();
+        check_StartCheckpoint_State(staker);
+
+        // 6. Complete in progress checkpoint
+        staker.completeCheckpoint();
+        check_CompleteCheckpoint_EarnOnBeacon_State(staker, expectedEarnedGwei);
+    }
+
+    function _pauseForkAndUpgrade() internal {
+        // 1. Pause starting checkpoint, completing, and credential proofs
+        cheats.prank(pauserMultisig);
+        eigenPodManager.pause(
+            2 ** PAUSED_START_CHECKPOINT |
+            2 ** PAUSED_EIGENPODS_VERIFY_CREDENTIALS |
+            2 ** PAUSED_VERIFY_STALE_BALANCE |
+            2 ** PAUSED_EIGENPODS_VERIFY_CHECKPOINT_PROOFS
+        );
+
+        // 2. Fork to Pectra
+        uint64 pectraForkTimestamp = uint64(block.timestamp) + 12;
+        BeaconChainMock_DenebForkable(address(beaconChain)).forkToPectra(pectraForkTimestamp);
+
+        // 3. Upgrade EigenPodManager & EigenPod
+        _upgradeEigenLayerContracts();
+
+        // 4. Set proof timestamp setter to operations multisig
+        cheats.prank(eigenPodManager.owner());
+        eigenPodManager.setProofTimestampSetter(address(operationsMultisig));
+    }
+
+    function _setTimestampAndUnpause() internal {
+        // 1. Set Timestamp
+        cheats.startPrank(eigenPodManager.proofTimestampSetter());
+        eigenPodManager.setPectraForkTimestamp(
+            BeaconChainMock_DenebForkable(address(beaconChain)).pectraForkTimestamp()
+        );
+        cheats.stopPrank();
+
+        // 2. Randomly warp to just after the fork timestamp
+        // If we do not warp, proofs will be against deneb state
+        if (_randBool()) {
+            // If we warp, proofs will be against electra state
+            cheats.warp(block.timestamp + 1); 
+        }
+
+        // 3. Unpause
+        cheats.prank(eigenLayerPauserReg.unpauser());
+        eigenPodManager.unpause(0);
+    }
+}