refactor: destruct elements from sv [sup-9184]

script/forge-scripts/Deploy.SuperVault.s.sol

@@ -41,14 +41,12 @@ contract MainnetDeploySuperVault is Script {
         /// @dev TODO set later the correct address, as this is currently rewards admin
         address REWARDS_ADMIN =
             isStaging ? 0x1F05a8Ff6d895Ba04C84c5031c5d63FA1afCDA6F : 0xf82F3D7Df94FC2994315c32322DA6238cA2A2f7f;
-        address VAULT_MANAGER = address(0xDEAD);
 
         address superVault = address(
             new SuperVault(
                 superRegistry,
                 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913, // USDC
                 REWARDS_ADMIN,
-                VAULT_MANAGER,
                 "USDCSuperVaultMoonwellFlagship",
                 type(uint256).max,
                 superformIds,

src/ISuperVault.sol

@@ -10,15 +10,6 @@ interface ISuperVault is IERC1155Receiver {
     //                  STRUCTS                                   //
     //////////////////////////////////////////////////////////////
 
-    /// @notice Struct to hold SuperVault strategy data
-    struct SuperVaultStrategyData {
-        address vaultManager;
-        uint256 numberOfSuperforms;
-        uint256 depositLimit;
-        uint256[] superformIds;
-        uint256[] weights;
-    }
-
     /// @notice Struct to hold rebalance arguments
     /// @notice superformIdsRebalanceFrom must be an ordered array of superform IDs with no duplicates
     /// @param superformIdsRebalanceFrom Array of superform IDs to rebalance from
@@ -83,9 +74,6 @@ interface ISuperVault is IERC1155Receiver {
     /// @notice Error thrown when the caller is not the pending management
     error NOT_PENDING_MANAGEMENT();
 
-    /// @notice Error thrown when the caller is not the vault manager
-    error NOT_VAULT_MANAGER();
-
     /// @notice Error thrown when a superform ID is not whitelisted
     error SUPERFORM_NOT_WHITELISTED();
 
@@ -143,10 +131,6 @@ interface ISuperVault is IERC1155Receiver {
     /// @param isWhitelisted Array of booleans indicating whether to whitelist or blacklist
     function setWhitelist(uint256[] memory superformIds, bool[] memory isWhitelisted) external;
 
-    /// @notice Sets the vault manager
-    /// @param vaultManager_ The new vault manager
-    function setVaultManager(address vaultManager_) external;
-
     /// @notice Returns the SuperVault data
     /// @return numberOfSuperforms The number of Superforms
     /// @return superformIds Array of Superform IDs

src/ISuperVaultFactory.sol

@@ -95,15 +95,13 @@ interface ISuperVaultFactory {
     /// @dev Sets pending management to deployer, deployer will have to accept management in SuperVault
     /// @param asset_ Address of the asset token
     /// @param strategist_ Address of the strategist
-    /// @param vaultManager_ Address of the vault manager
     /// @param name_ Name of the strategy
     /// @param depositLimit_ Maximum deposit limit
     /// @param superformIds_ Array of Superform IDs
     /// @param startingWeights_ Array of starting weights for each Superform
     function createSuperVault(
         address asset_,
         address strategist_,
-        address vaultManager_,
         string memory name_,
         uint256 depositLimit_,
         uint256[] memory superformIds_,

src/SuperVault.sol

@@ -52,15 +52,24 @@ contract SuperVault is BaseStrategy, ISuperVault {
     /// @notice The maximum allowed slippage (1% = 100)
     uint256 public constant MAX_SLIPPAGE = 100;
 
-    /// @notice Struct containing SuperVault strategy data
-    SuperVaultStrategyData private SV;
+    /// @notice The number of superforms in the vault
+    uint256 numberOfSuperforms;
+
+    /// @notice The deposit limit for the vault
+    uint256 depositLimit;
 
     /// @notice Mapping to track whitelisted Superform IDs
     mapping(uint256 => bool) public whitelistedSuperformIds;
 
     /// @notice Array of whitelisted Superform IDs for easy access
     uint256[] public whitelistedSuperformIdArray;
 
+    /// @notice Array of superform IDs in the vault
+    uint256[] superformIds;
+
+    /// @notice Array of weights for each superform in the vault
+    uint256[] weights;
+
     //////////////////////////////////////////////////////////////
     //                       MODIFIERS                          //
     //////////////////////////////////////////////////////////////
@@ -73,14 +82,6 @@ contract SuperVault is BaseStrategy, ISuperVault {
         _;
     }
 
-    /// @notice Ensures that only the Vault Manager can call the function
-    modifier onlyVaultManager() {
-        if (SV.vaultManager != msg.sender) {
-            revert NOT_VAULT_MANAGER();
-        }
-        _;
-    }
-
     //////////////////////////////////////////////////////////////
     //                       CONSTRUCTOR                        //
     //////////////////////////////////////////////////////////////
@@ -95,15 +96,14 @@ contract SuperVault is BaseStrategy, ISuperVault {
         address superRegistry_,
         address asset_,
         address strategist_,
-        address vaultManager_,
         string memory name_,
         uint256 depositLimit_,
         uint256[] memory superformIds_,
         uint256[] memory startingWeights_
     )
         BaseStrategy(asset_, name_)
     {
-        uint256 numberOfSuperforms = superformIds_.length;
+        numberOfSuperforms = superformIds_.length;
 
         if (numberOfSuperforms == 0) {
             revert ZERO_SUPERFORMS();
@@ -113,7 +113,7 @@ contract SuperVault is BaseStrategy, ISuperVault {
             revert ARRAY_LENGTH_MISMATCH();
         }
 
-        if (superRegistry_ == address(0) || strategist_ == address(0) || vaultManager_ == address(0)) {
+        if (superRegistry_ == address(0) || strategist_ == address(0)) {
             revert ZERO_ADDRESS();
         }
 
@@ -156,20 +156,20 @@ contract SuperVault is BaseStrategy, ISuperVault {
         if (totalWeight != TOTAL_WEIGHT) revert INVALID_WEIGHTS();
 
         strategist = strategist_;
-        SV.vaultManager = vaultManager_;
-        SV.numberOfSuperforms = numberOfSuperforms;
-        SV.superformIds = superformIds_;
-        SV.weights = startingWeights_;
-        SV.depositLimit = depositLimit_;
+        for (uint256 i; i < numberOfSuperforms; ++i) {
+            superformIds[i] = superformIds_[i];
+            weights[i] = startingWeights_[i];
+        }
+        depositLimit = depositLimit_;
     }
 
     //////////////////////////////////////////////////////////////
     //                  EXTERNAL  FUNCTIONS                     //
     //////////////////////////////////////////////////////////////
 
     /// @inheritdoc ISuperVault
-    function setDepositLimit(uint256 depositLimit_) external override onlyVaultManager {
-        SV.depositLimit = depositLimit_;
+    function setDepositLimit(uint256 depositLimit_) external override onlyManagement {
+        depositLimit = depositLimit_;
 
         emit DepositLimitSet(depositLimit_);
     }
@@ -198,12 +198,11 @@ contract SuperVault is BaseStrategy, ISuperVault {
 
         {
             /// @dev caching to avoid multiple SLOADs
-            uint256 numberOfSuperforms = SV.numberOfSuperforms;
             uint256 foundCount;
 
             for (uint256 i; i < lenRebalanceFrom; ++i) {
                 for (uint256 j; j < numberOfSuperforms; ++j) {
-                    if (rebalanceArgs.superformIdsRebalanceFrom[i] == SV.superformIds[j]) {
+                    if (rebalanceArgs.superformIdsRebalanceFrom[i] == superformIds[j]) {
                         foundCount++;
                         break;
                     }
@@ -246,9 +245,9 @@ contract SuperVault is BaseStrategy, ISuperVault {
 
         ISuperformRouterPlus(routerPlus).rebalanceMultiPositions(args);
 
-        /// @dev step 3: update SV data
+        /// @dev step 3: update data
         /// @notice no issue about reentrancy as the external contracts are trusted
-        /// @notice updateSV emits rebalance event
+        /// @notice updateSVData emits rebalance event
         _updateSVData(superPositions, rebalanceArgs.finalSuperformIds);
     }
 
@@ -271,7 +270,7 @@ contract SuperVault is BaseStrategy, ISuperVault {
     )
         external
         override
-        onlyVaultManager
+        onlyManagement
     {
         uint256 length = superformIds.length;
         if (length != isWhitelisted.length) revert ARRAY_LENGTH_MISMATCH();
@@ -281,14 +280,6 @@ contract SuperVault is BaseStrategy, ISuperVault {
         }
     }
 
-    /// @inheritdoc ISuperVault
-    function setVaultManager(address vaultManager_) external override onlyManagement {
-        if (vaultManager_ == address(0)) revert ZERO_ADDRESS();
-        SV.vaultManager = vaultManager_;
-
-        emit VaultManagerSet(vaultManager_);
-    }
-
     //////////////////////////////////////////////////////////////
     //                 EXTERNAL VIEW/PURE FUNCTIONS             //
     //////////////////////////////////////////////////////////////
@@ -299,7 +290,7 @@ contract SuperVault is BaseStrategy, ISuperVault {
         view
         returns (uint256 numberOfSuperforms, uint256[] memory superformIds, uint256[] memory weights)
     {
-        return (SV.numberOfSuperforms, SV.superformIds, SV.weights);
+        return (numberOfSuperforms, superformIds, weights);
     }
 
     /// @inheritdoc ISuperVault
@@ -361,7 +352,6 @@ contract SuperVault is BaseStrategy, ISuperVault {
     /// @inheritdoc BaseStrategy
     function availableDepositLimit(address /*_owner*/ ) public view override returns (uint256) {
         uint256 totalAssets = TokenizedStrategy.totalAssets();
-        uint256 depositLimit = SV.depositLimit;
         return totalAssets >= depositLimit ? 0 : depositLimit - totalAssets;
     }
 
@@ -412,8 +402,7 @@ contract SuperVault is BaseStrategy, ISuperVault {
     /// @return totalAssets The total assets of the vault
     function _harvestAndReport() internal view override returns (uint256 totalAssets) {
         uint256 totalAssetsInVaults;
-        uint256 numberOfSuperforms = SV.numberOfSuperforms;
-        uint256[] memory superformIds = SV.superformIds;
+        uint256[] memory superformIds = superformIds;
 
         address superPositions = _getAddress(keccak256("SUPER_POSITIONS"));
 
@@ -444,9 +433,8 @@ contract SuperVault is BaseStrategy, ISuperVault {
         view
         returns (MultiVaultSFData memory mvData)
     {
-        uint256 numberOfSuperforms = SV.numberOfSuperforms;
 
-        mvData.superformIds = SV.superformIds;
+        mvData.superformIds = superformIds;
         mvData.amounts = new uint256[](numberOfSuperforms);
         mvData.maxSlippages = new uint256[](numberOfSuperforms);
         mvData.liqRequests = new LiqRequest[](numberOfSuperforms);
@@ -468,11 +456,11 @@ contract SuperVault is BaseStrategy, ISuperVault {
 
             if (isDeposit) {
                 /// @notice rounding down to avoid one-off issue
-                mvData.amounts[i] = amount_.mulDiv(SV.weights[i], TOTAL_WEIGHT, Math.Rounding.Down);
+                mvData.amounts[i] = amount_.mulDiv(weights[i], TOTAL_WEIGHT, Math.Rounding.Down);
                 mvData.outputAmounts[i] = superformContract.previewDepositTo(mvData.amounts[i]);
             } else {
                 /// @dev assets
-                mvData.outputAmounts[i] = amount_.mulDiv(SV.weights[i], TOTAL_WEIGHT, Math.Rounding.Down);
+                mvData.outputAmounts[i] = amount_.mulDiv(weights[i], TOTAL_WEIGHT, Math.Rounding.Down);
                 /// @dev shares - in 4626Form this uses convertToShares in 5115Form this uses previewDeposit
                 mvData.amounts[i] = superformContract.previewDepositTo(mvData.outputAmounts[i]);
             }
@@ -684,9 +672,9 @@ contract SuperVault is BaseStrategy, ISuperVault {
         newWeights[length - 1] = TOTAL_WEIGHT - totalAssignedWeight;
 
         /// @dev update SV weights
-        SV.weights = newWeights;
-        SV.superformIds = finalSuperformIds;
-        SV.numberOfSuperforms = length;
+        weights = newWeights;
+        superformIds = finalSuperformIds;
+        numberOfSuperforms = length;
 
         emit RebalanceComplete(finalSuperformIds, newWeights);
     }

src/SuperVaultFactory.sol

@@ -74,7 +74,6 @@ contract SuperVaultFactory is ISuperVaultFactory, AccessControl {
     function createSuperVault(
         address asset_,
         address strategist_,
-        address vaultManager_,
         string memory name_,
         uint256 depositLimit_,
         uint256[] memory superformIds_,
@@ -105,7 +104,6 @@ contract SuperVaultFactory is ISuperVaultFactory, AccessControl {
                 address(superRegistry),
                 asset_,
                 strategist_,
-                vaultManager_,
                 name_,
                 depositLimit_,
                 superformIds_,