set allocated to maxWithdraw()

src/core/module/Strategy.sol

@@ -67,6 +67,8 @@ abstract contract StrategyModule is Shared {
     /// @dev This should be used as a cricuit-breaker to exclude a faulty strategy from being harvest or rebalanced.
     /// It also deduct all the deposited amounts into the strategy as loss, and uses a loss socialization mechanism.
     /// This is needed, in case the aggregation vault can no longer withdraw from a certain strategy.
+    /// In the case of switching a strategy from Emergency to Active again, the max withdrawable amount from the strategy
+    /// will be set as the allocated amount, and will be set as interest during the next time gulp() is called.
     function toggleStrategyEmergencyStatus(address _strategy) external virtual nonReentrant {
         if (_strategy == address(0)) revert Errors.CanNotToggleStrategyEmergencyStatus();
 
@@ -86,7 +88,7 @@ abstract contract StrategyModule is Shared {
             $.strategies[_strategy].status = IEulerAggregationVault.StrategyStatus.Active;
 
             $.totalAllocationPoints += strategyCached.allocationPoints;
-            $.totalAllocated += strategyCached.allocated;
+            $.totalAllocated += IERC4626(_strategy).maxWithdraw(address(this));
         }
     }
 

test/e2e/ToggleStrategyEmergencyStatusE2ETest.t.sol

@@ -15,6 +15,7 @@ import {
 
 contract ToggleStrategyEmergencyStatusE2ETest is EulerAggregationVaultBase {
     uint256 user1InitialBalance = 100000e18;
+    uint256 user2InitialBalance = 100000e18;
 
     IEVault eTSTsecondary;
 
@@ -38,6 +39,7 @@ contract ToggleStrategyEmergencyStatusE2ETest is EulerAggregationVaultBase {
         }
 
         assetTST.mint(user1, user1InitialBalance);
+        assetTST.mint(user2, user2InitialBalance);
     }
 
     function testToggleStrategyEmergencyStatus() public {
@@ -178,4 +180,135 @@ contract ToggleStrategyEmergencyStatusE2ETest is EulerAggregationVaultBase {
         vm.expectRevert(ErrorsLib.CanNotRemoveStrategyInEmergencyStatus.selector);
         eulerAggregationVault.removeStrategy(address(eTSTsecondary));
     }
+
+    function testSetEmergencyAndReactive() public {
+        uint256 amountToDeposit = 10000e18;
+
+        // deposit into aggregator
+        {
+            vm.startPrank(user1);
+            assetTST.approve(address(eulerAggregationVault), amountToDeposit);
+            eulerAggregationVault.deposit(amountToDeposit, user1);
+            vm.stopPrank();
+
+            vm.startPrank(user2);
+            assetTST.approve(address(eulerAggregationVault), amountToDeposit);
+            eulerAggregationVault.deposit(amountToDeposit, user2);
+            vm.stopPrank();
+        }
+
+        // rebalance into strategy
+        // 2500 total points; 1000 for reserve(40%), 500(20%) for eTST, 1000(40%) for eTSTsecondary
+        // 10k deposited; 4k for reserve, 2k for eTST, 4k for eTSTsecondary
+        vm.warp(block.timestamp + 86400);
+        {
+            IEulerAggregationVault.Strategy memory eTSTstrategyBefore = eulerAggregationVault.getStrategy(address(eTST));
+            IEulerAggregationVault.Strategy memory eTSTsecondarystrategyBefore =
+                eulerAggregationVault.getStrategy(address(eTSTsecondary));
+
+            assertEq(eTST.convertToAssets(eTST.balanceOf(address(eulerAggregationVault))), eTSTstrategyBefore.allocated);
+            assertEq(
+                eTSTsecondary.convertToAssets(eTSTsecondary.balanceOf(address(eulerAggregationVault))),
+                eTSTsecondarystrategyBefore.allocated
+            );
+
+            uint256 expectedeTSTStrategyCash = eulerAggregationVault.totalAssetsAllocatable()
+                * eTSTstrategyBefore.allocationPoints / eulerAggregationVault.totalAllocationPoints();
+            uint256 expectedeTSTsecondaryStrategyCash = eulerAggregationVault.totalAssetsAllocatable()
+                * eTSTsecondarystrategyBefore.allocationPoints / eulerAggregationVault.totalAllocationPoints();
+
+            assertTrue(expectedeTSTStrategyCash != 0);
+            assertTrue(expectedeTSTsecondaryStrategyCash != 0);
+
+            address[] memory strategiesToRebalance = new address[](2);
+            strategiesToRebalance[0] = address(eTST);
+            strategiesToRebalance[1] = address(eTSTsecondary);
+            vm.prank(user1);
+            rebalancer.executeRebalance(address(eulerAggregationVault), strategiesToRebalance);
+
+            assertEq(
+                eulerAggregationVault.totalAllocated(), expectedeTSTStrategyCash + expectedeTSTsecondaryStrategyCash
+            );
+            assertEq(eTST.convertToAssets(eTST.balanceOf(address(eulerAggregationVault))), expectedeTSTStrategyCash);
+            assertEq(
+                eTSTsecondary.convertToAssets(eTSTsecondary.balanceOf(address(eulerAggregationVault))),
+                expectedeTSTsecondaryStrategyCash
+            );
+            assertEq((eulerAggregationVault.getStrategy(address(eTST))).allocated, expectedeTSTStrategyCash);
+            assertEq(
+                (eulerAggregationVault.getStrategy(address(eTSTsecondary))).allocated, expectedeTSTsecondaryStrategyCash
+            );
+            assertEq(
+                assetTST.balanceOf(address(eulerAggregationVault)),
+                amountToDeposit * 2 - (expectedeTSTStrategyCash + expectedeTSTsecondaryStrategyCash)
+            );
+        }
+
+        // set eTST in emergency mode
+        uint256 totalAllocationBefore = eulerAggregationVault.totalAllocationPoints();
+        vm.prank(manager);
+        eulerAggregationVault.toggleStrategyEmergencyStatus(address(eTST));
+        assertEq(
+            eulerAggregationVault.totalAllocationPoints(),
+            totalAllocationBefore - (eulerAggregationVault.getStrategy(address(eTST))).allocationPoints
+        );
+
+        // user 1 full withdraw, will have to withdraw from strategy as cash reserve is not enough, user should be able to withdraw
+        {
+            uint256 amountToWithdraw = eulerAggregationVault.balanceOf(user1);
+            uint256 user1AssetTSTBalanceBefore = assetTST.balanceOf(user1);
+            uint256 user2AssetTSTBalanceBefore = assetTST.balanceOf(user2);
+            uint256 expectedAssets = eulerAggregationVault.convertToAssets(amountToWithdraw);
+            uint256 totalAssetsDepositedBefore = eulerAggregationVault.totalAssetsDeposited();
+
+            assertTrue(totalAssetsDepositedBefore != 0);
+
+            vm.prank(user1);
+            eulerAggregationVault.redeem(amountToWithdraw, user1, user1);
+
+            assertTrue(eTST.balanceOf(address(eulerAggregationVault)) != 0);
+            assertEq(eulerAggregationVault.totalAssetsDeposited(), totalAssetsDepositedBefore - expectedAssets);
+            assertEq(eulerAggregationVault.totalSupply(), eulerAggregationVault.balanceOf(user2));
+            assertEq(assetTST.balanceOf(user1), user1AssetTSTBalanceBefore + expectedAssets);
+            assertEq(assetTST.balanceOf(user2), user2AssetTSTBalanceBefore);
+        }
+
+        vm.warp(block.timestamp + 86400);
+
+        // re-activate eTST back again
+        totalAllocationBefore = eulerAggregationVault.totalAllocationPoints();
+        vm.prank(manager);
+        eulerAggregationVault.toggleStrategyEmergencyStatus(address(eTST));
+        assertEq(
+            eulerAggregationVault.totalAllocationPoints(),
+            totalAllocationBefore + (eulerAggregationVault.getStrategy(address(eTST))).allocationPoints
+        );
+
+        eulerAggregationVault.gulp();
+
+        // user 2 full withdraw
+        {
+            uint256 amountToWithdraw = eulerAggregationVault.balanceOf(user2);
+            uint256 user2AssetTSTBalanceBefore = assetTST.balanceOf(user2);
+            uint256 expectedAssets = eulerAggregationVault.convertToAssets(amountToWithdraw);
+            uint256 totalAssetsDepositedBefore = eulerAggregationVault.totalAssetsDeposited();
+
+            assertTrue(totalAssetsDepositedBefore != 0);
+
+            vm.prank(user2);
+            eulerAggregationVault.redeem(amountToWithdraw, user2, user2);
+
+            assertEq(eTST.balanceOf(address(eulerAggregationVault)), 0);
+            assertEq(eulerAggregationVault.totalAssetsDeposited(), 0);
+            assertEq(eulerAggregationVault.totalSupply(), 0);
+            assertEq(assetTST.balanceOf(user2), user2AssetTSTBalanceBefore + expectedAssets);
+        }
+
+        EulerAggregationVault.Strategy memory eTSTsecondaryStrategy =
+            eulerAggregationVault.getStrategy(address(eTSTsecondary));
+        EulerAggregationVault.AggregationVaultSavingRate memory avsr =
+            eulerAggregationVault.getAggregationVaultSavingRate();
+
+        assertEq(avsr.interestLeft, eTSTsecondaryStrategy.allocated);
+    }
 }