Internal review

src/core/Dispatch.sol

@@ -7,18 +7,27 @@ import {RewardsModule} from "./module/Rewards.sol";
 import {StrategyModule} from "./module/Strategy.sol";
 import {FeeModule} from "./module/Fee.sol";
 import {RebalanceModule} from "./module/Rebalance.sol";
+import {WithdrawalQueueModule} from "./module/WithdrawalQueue.sol";
 
 /// @title Dispatch contract
 /// @custom:security-contact [email protected]
 /// @author Euler Labs (https://www.eulerlabs.com/)
 /// @dev This contract implement the modifier to use for forwarding calls to a specific module using delegateCall.
 /// @dev Copied from https://github.com/euler-xyz/euler-vault-kit/blob/55d1a1fd7d572372f1c8b9f58aba0604bda3ca4f/src/EVault/Dispatch.sol.
-abstract contract Dispatch is RewardsModule, HooksModule, FeeModule, StrategyModule, RebalanceModule {
+abstract contract Dispatch is
+    RewardsModule,
+    HooksModule,
+    FeeModule,
+    StrategyModule,
+    RebalanceModule,
+    WithdrawalQueueModule
+{
     address public immutable rewardsModule;
     address public immutable hooksModule;
     address public immutable feeModule;
     address public immutable strategyModule;
     address public immutable rebalanceModule;
+    address public immutable withdrawalQueueModule;
 
     /// @dev Constructor.
     /// @param _rewardsModule Address of Rewards module.
@@ -31,13 +40,15 @@ abstract contract Dispatch is RewardsModule, HooksModule, FeeModule, StrategyMod
         address _hooksModule,
         address _feeModule,
         address _strategyModule,
-        address _rebalanceModule
+        address _rebalanceModule,
+        address _withdrawalQueueModule
     ) {
         rewardsModule = _rewardsModule;
         hooksModule = _hooksModule;
         feeModule = _feeModule;
         strategyModule = _strategyModule;
         rebalanceModule = _rebalanceModule;
+        withdrawalQueueModule = _withdrawalQueueModule;
     }
 
     // Modifier proxies the function call to a module and low-level returns the result

src/core/EulerAggregationVault.sol

@@ -6,7 +6,6 @@ import {IERC4626} from "@openzeppelin/contracts/interfaces/IERC4626.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import {IBalanceTracker} from "reward-streams/interfaces/IBalanceTracker.sol";
 import {IEulerAggregationVault} from "./interface/IEulerAggregationVault.sol";
-import {IWithdrawalQueue} from "./interface/IWithdrawalQueue.sol";
 // contracts
 import {Dispatch} from "./Dispatch.sol";
 import {
@@ -49,6 +48,8 @@ contract EulerAggregationVault is
     bytes32 public constant STRATEGY_OPERATOR_ADMIN = keccak256("STRATEGY_OPERATOR_ADMIN");
     bytes32 public constant AGGREGATION_VAULT_MANAGER = keccak256("AGGREGATION_VAULT_MANAGER");
     bytes32 public constant AGGREGATION_VAULT_MANAGER_ADMIN = keccak256("AGGREGATION_VAULT_MANAGER_ADMIN");
+    bytes32 public constant WITHDRAWAL_QUEUE_MANAGER = keccak256("WITHDRAWAL_QUEUE_MANAGER");
+    bytes32 public constant WITHDRAWAL_QUEUE_MANAGER_ADMIN = keccak256("WITHDRAWAL_QUEUE_MANAGER_ADMIN");
 
     /// @dev Constructor.
     constructor(ConstructorParams memory _constructorParams)
@@ -57,7 +58,8 @@ contract EulerAggregationVault is
             _constructorParams.hooksModule,
             _constructorParams.feeModule,
             _constructorParams.strategyModule,
-            _constructorParams.rebalanceModule
+            _constructorParams.rebalanceModule,
+            _constructorParams.withdrawalQueueModule
         )
     {}
 
@@ -72,7 +74,6 @@ contract EulerAggregationVault is
 
         AggregationVaultStorage storage $ = Storage._getAggregationVaultStorage();
         $.locked = REENTRANCYLOCK__UNLOCKED;
-        $.withdrawalQueue = _initParams.withdrawalQueuePlugin;
         $.balanceTracker = _initParams.balanceTracker;
         $.strategies[address(0)] = IEulerAggregationVault.Strategy({
             allocated: 0,
@@ -89,8 +90,7 @@ contract EulerAggregationVault is
         _setRoleAdmin(GUARDIAN, GUARDIAN_ADMIN);
         _setRoleAdmin(STRATEGY_OPERATOR, STRATEGY_OPERATOR_ADMIN);
         _setRoleAdmin(AGGREGATION_VAULT_MANAGER, AGGREGATION_VAULT_MANAGER_ADMIN);
-
-        IWithdrawalQueue(_initParams.withdrawalQueuePlugin).init(_initParams.aggregationVaultOwner);
+        _setRoleAdmin(WITHDRAWAL_QUEUE_MANAGER, WITHDRAWAL_QUEUE_MANAGER_ADMIN);
     }
 
     /// @dev See {FeeModule-setFeeRecipient}.
@@ -188,8 +188,17 @@ contract EulerAggregationVault is
     /// @dev See {RewardsModule-disableBalanceForwarder}.
     function disableBalanceForwarder() external override use(rewardsModule) {}
 
+    /// @dev See {RebalanceModule-rebalance}.
     function rebalance(address[] calldata _strategies) external override use(rebalanceModule) {}
 
+    /// @dev See {WithdrawalQueue-reorderWithdrawalQueue}.
+    function reorderWithdrawalQueue(uint8 _index1, uint8 _index2)
+        external
+        override
+        onlyRole(WITHDRAWAL_QUEUE_MANAGER)
+        use(withdrawalQueueModule)
+    {}
+
     /// @notice Harvest all the strategies. Any positive yiled should be gupled by calling gulp() after harvesting.
     /// @dev This function will loop through the strategies following the withdrawal queue order and harvest all.
     /// @dev Harvest yield and losses will be aggregated and only net yield/loss will be accounted.
@@ -200,7 +209,7 @@ contract EulerAggregationVault is
     }
 
     /// @notice update accrued interest
-    function updateInterestAccrued() external {
+    function updateInterestAccrued() external nonReentrant {
         return _updateInterestAccrued();
     }
 
@@ -209,53 +218,6 @@ contract EulerAggregationVault is
         _gulp();
     }
 
-    /// @notice Execute a withdraw from a strategy.
-    /// @dev Can only be called from the WithdrawalQueue contract.
-    /// @param _strategy Strategy's address.
-    /// @param _withdrawAmount Amount to withdraw.
-    function executeStrategyWithdraw(address _strategy, uint256 _withdrawAmount) external returns (uint256) {
-        _isCallerWithdrawalQueue();
-
-        AggregationVaultStorage storage $ = Storage._getAggregationVaultStorage();
-
-        if ($.strategies[_strategy].status != IEulerAggregationVault.StrategyStatus.Active) return 0;
-
-        // Update allocated assets
-        $.strategies[_strategy].allocated -= uint120(_withdrawAmount);
-        $.totalAllocated -= _withdrawAmount;
-
-        // Do actual withdraw from strategy
-        IERC4626(_strategy).withdraw(_withdrawAmount, address(this), address(this));
-
-        return _withdrawAmount;
-    }
-
-    /// @notice Execute a withdraw from the AggregationVault
-    /// @dev This function should be called and can only be called by the WithdrawalQueue.
-    /// @param _caller Withdraw call initiator.
-    /// @param _receiver Receiver of the withdrawn asset.
-    /// @param _owner Owner of shares to withdraw against.
-    /// @param _assets Amount of asset to withdraw.
-    /// @param _shares Amount of shares to withdraw against.
-    function executeAggregationVaultWithdraw(
-        address _caller,
-        address _receiver,
-        address _owner,
-        uint256 _assets,
-        uint256 _shares
-    ) external {
-        _isCallerWithdrawalQueue();
-
-        if (_receiver == address(this)) revert Errors.CanNotReceiveWithdrawnAsset();
-
-        AggregationVaultStorage storage $ = Storage._getAggregationVaultStorage();
-        $.totalAssetsDeposited -= _assets;
-
-        super._withdraw(_caller, _receiver, _owner, _assets, _shares);
-
-        _gulp();
-    }
-
     /// @notice Get strategy params.
     /// @param _strategy strategy's address
     /// @return Strategy struct
@@ -272,7 +234,7 @@ contract EulerAggregationVault is
     }
 
     /// @notice Get saving rate data.
-    /// @return avsr AggregationVaultSavingRate struct.
+    /// @return AggregationVaultSavingRate struct.
     function getAggregationVaultSavingRate() external view returns (AggregationVaultSavingRate memory) {
         AggregationVaultStorage storage $ = Storage._getAggregationVaultStorage();
         AggregationVaultSavingRate memory avsr = AggregationVaultSavingRate({
@@ -308,23 +270,23 @@ contract EulerAggregationVault is
         return $.totalAssetsDeposited;
     }
 
-    /// @notice Get the WithdrawalQueue plugin address.
-    /// @return address Withdrawal queue address.
-    function withdrawalQueue() external view returns (address) {
-        AggregationVaultStorage storage $ = Storage._getAggregationVaultStorage();
-
-        return $.withdrawalQueue;
-    }
-
     /// @notice Get the performance fee config.
     /// @return adddress Fee recipient.
     /// @return uint256 Fee percentage.
-    function performanceFeeConfig() external view returns (address, uint256) {
+    function performanceFeeConfig() external view virtual returns (address, uint256) {
         AggregationVaultStorage storage $ = Storage._getAggregationVaultStorage();
 
         return ($.feeRecipient, $.performanceFee);
     }
 
+    /// @notice Return the withdrawal queue length.
+    /// @return uint256 length.
+    function withdrawalQueue() external view virtual returns (address[] memory) {
+        AggregationVaultStorage storage $ = Storage._getAggregationVaultStorage();
+
+        return $.withdrawalQueue;
+    }
+
     /// @dev See {IERC4626-deposit}.
     /// @dev Call DEPOSIT hook if enabled.
     function deposit(uint256 _assets, address _receiver) public override nonReentrant returns (uint256) {
@@ -393,10 +355,8 @@ contract EulerAggregationVault is
     /// @notice get the total assets allocatable
     /// @dev the total assets allocatable is the amount of assets deposited into the aggregator + assets already deposited into strategies
     /// @return uint256 total assets
-    function totalAssetsAllocatable() public view returns (uint256) {
-        AggregationVaultStorage storage $ = Storage._getAggregationVaultStorage();
-
-        return IERC20(asset()).balanceOf(address(this)) + $.totalAllocated;
+    function totalAssetsAllocatable() external view returns (uint256) {
+        return _totalAssetsAllocatable();
     }
 
     /// @dev See {IERC4626-_deposit}.
@@ -417,9 +377,42 @@ contract EulerAggregationVault is
         AggregationVaultStorage storage $ = Storage._getAggregationVaultStorage();
         uint256 assetsRetrieved = IERC20(asset()).balanceOf(address(this));
 
-        IWithdrawalQueue($.withdrawalQueue).callWithdrawalQueue(
-            _caller, _receiver, _owner, _assets, _shares, assetsRetrieved
-        );
+        if (assetsRetrieved < _assets) {
+            uint256 numStrategies = $.withdrawalQueue.length;
+            for (uint256 i; i < numStrategies; ++i) {
+                IERC4626 strategy = IERC4626($.withdrawalQueue[i]);
+
+                if ($.strategies[address(strategy)].status != IEulerAggregationVault.StrategyStatus.Active) continue;
+
+                uint256 underlyingBalance = strategy.maxWithdraw(address(this));
+                uint256 desiredAssets = _assets - assetsRetrieved;
+                uint256 withdrawAmount = (underlyingBalance > desiredAssets) ? desiredAssets : underlyingBalance;
+
+                // Update allocated assets
+                $.strategies[address(strategy)].allocated -= uint120(withdrawAmount);
+                $.totalAllocated -= withdrawAmount;
+
+                // Do actual withdraw from strategy
+                IERC4626(address(strategy)).withdraw(withdrawAmount, address(this), address(this));
+
+                // update _availableAssets
+                assetsRetrieved += withdrawAmount;
+
+                if (assetsRetrieved >= _assets) {
+                    break;
+                }
+            }
+        }
+
+        if (assetsRetrieved < _assets) {
+            revert Errors.NotEnoughAssets();
+        }
+
+        $.totalAssetsDeposited -= _assets;
+
+        super._withdraw(_caller, _receiver, _owner, _assets, _shares);
+
+        _gulp();
     }
 
     /// @dev Loop through stratgies, aggregate positive yield and loss and account for net amount.
@@ -430,13 +423,10 @@ contract EulerAggregationVault is
 
         AggregationVaultStorage storage $ = Storage._getAggregationVaultStorage();
 
-        (address[] memory withdrawalQueueArray, uint256 length) =
-            IWithdrawalQueue($.withdrawalQueue).getWithdrawalQueueArray();
-
         uint256 totalYield;
         uint256 totalLoss;
-        for (uint256 i; i < length; ++i) {
-            (uint256 yield, uint256 loss) = _executeHarvest(withdrawalQueueArray[i]);
+        for (uint256 i; i < $.withdrawalQueue.length; ++i) {
+            (uint256 yield, uint256 loss) = _executeHarvest($.withdrawalQueue[i]);
 
             totalYield += yield;
             totalLoss += loss;
@@ -539,11 +529,4 @@ contract EulerAggregationVault is
             balanceTracker.balanceTrackerHook(to, super.balanceOf(to), false);
         }
     }
-
-    /// @dev Check if caller is WithdrawalQueue address, if not revert.
-    function _isCallerWithdrawalQueue() internal view {
-        AggregationVaultStorage storage $ = Storage._getAggregationVaultStorage();
-
-        if (msg.sender != $.withdrawalQueue) revert Errors.NotWithdrawaQueue();
-    }
 }

src/core/EulerAggregationVaultFactory.sol

@@ -20,6 +20,7 @@ contract EulerAggregationVaultFactory {
     address public immutable feeModule;
     address public immutable strategyModule;
     address public immutable rebalanceModule;
+    address public immutable withdrawalQueueModule;
     /// aggregation vault implementation address
     address public immutable aggregationVaultImpl;
 
@@ -34,11 +35,10 @@ contract EulerAggregationVaultFactory {
         address feeModuleImpl;
         address strategyModuleImpl;
         address rebalanceModuleImpl;
+        address withdrawalQueueModuleImpl;
     }
 
-    event DeployEulerAggregationVault(
-        address indexed _owner, address _aggregationVault, address indexed _withdrawalQueueImpl, address indexed _asset
-    );
+    event DeployEulerAggregationVault(address indexed _owner, address _aggregationVault, address indexed _asset);
 
     /// @notice Constructor.
     /// @param _factoryParams FactoryParams struct.
@@ -49,14 +49,16 @@ contract EulerAggregationVaultFactory {
         feeModule = Clones.clone(_factoryParams.feeModuleImpl);
         strategyModule = Clones.clone(_factoryParams.strategyModuleImpl);
         rebalanceModule = Clones.clone(_factoryParams.rebalanceModuleImpl);
+        withdrawalQueueModule = Clones.clone(_factoryParams.withdrawalQueueModuleImpl);
 
         IEulerAggregationVault.ConstructorParams memory aggregationVaultConstructorParams = IEulerAggregationVault
             .ConstructorParams({
             rewardsModule: rewardsModule,
             hooksModule: hooksModule,
             feeModule: feeModule,
             strategyModule: strategyModule,
-            rebalanceModule: rebalanceModule
+            rebalanceModule: rebalanceModule,
+            withdrawalQueueModule: withdrawalQueueModule
         });
         aggregationVaultImpl = address(new EulerAggregationVault(aggregationVaultConstructorParams));
     }
@@ -71,7 +73,6 @@ contract EulerAggregationVaultFactory {
     /// @param _initialCashAllocationPoints The amount of points to initally allocate for cash reserve.
     /// @return eulerAggregationVault The address of the new deployed aggregation vault.
     function deployEulerAggregationVault(
-        address _withdrawalQueueImpl,
         address _asset,
         string memory _name,
         string memory _symbol,
@@ -82,7 +83,6 @@ contract EulerAggregationVaultFactory {
         IEulerAggregationVault.InitParams memory aggregationVaultInitParams = IEulerAggregationVault.InitParams({
             aggregationVaultOwner: msg.sender,
             asset: _asset,
-            withdrawalQueuePlugin: Clones.clone(_withdrawalQueueImpl),
             balanceTracker: balanceTracker,
             name: _name,
             symbol: _symbol,
@@ -92,7 +92,7 @@ contract EulerAggregationVaultFactory {
 
         aggregationVaults.push(address(eulerAggregationVault));
 
-        emit DeployEulerAggregationVault(msg.sender, address(eulerAggregationVault), _withdrawalQueueImpl, _asset);
+        emit DeployEulerAggregationVault(msg.sender, address(eulerAggregationVault), _asset);
 
         return eulerAggregationVault;
     }