refactor: additional snake case naming changes

Author: skimaharvey

src/core/MultistrategyVault.sol

@@ -334,7 +334,7 @@ contract MultistrategyVault is IMultistrategyVault {
      * @param name_ New name for the vault token
      * @custom:security Only callable by roleManager
      */
-    function set_name(string memory name_) external override {
+    function setName(string memory name_) external override {
         require(msg.sender == roleManager, NotAllowed());
         name = name_;
     }
@@ -345,7 +345,7 @@ contract MultistrategyVault is IMultistrategyVault {
      * @param symbol_ New symbol ticker for the vault token
      * @custom:security Only callable by roleManager
      */
-    function set_symbol(string memory symbol_) external override {
+    function setSymbol(string memory symbol_) external override {
         require(msg.sender == roleManager, NotAllowed());
         symbol = symbol_;
     }
@@ -1667,15 +1667,6 @@ contract MultistrategyVault is IMultistrategyVault {
         return _convertToAssets(shares_, Rounding.ROUND_DOWN);
     }
 
-    /**
-     * @notice Returns the default withdrawal queue
-     * @dev Same as getDefaultQueue()
-     * @return queue Array of strategy addresses in withdrawal priority order
-     */
-    function defaultQueue() external view override returns (address[] memory) {
-        return _defaultQueue;
-    }
-
     /**
      * @notice Returns maximum assets that can be deposited for a receiver
      * @dev Checks against depositLimit or depositLimitModule (if set)
@@ -1821,31 +1812,6 @@ contract MultistrategyVault is IMultistrategyVault {
         return API_VERSION;
     }
 
-    // ============================================
-    // VIEW FUNCTIONS - STRATEGY QUERIES
-    // ============================================
-
-    /**
-     * @notice Calculates the unrealized losses for a withdrawal from strategy
-     * @dev Compares strategy's actual asset value vs recorded debt
-     *      If strategy is underwater, user takes proportional share of loss
-     *
-     *      Formula: loss = assetsNeeded - (assetsNeeded * strategyAssets / currentDebt)
-     *
-     * @param strategy_ Address of the strategy
-     * @param assetsNeeded_ Amount of assets to withdraw from strategy
-     * @return loss User's share of unrealized losses
-     */
-    function assess_share_of_unrealised_losses(
-        address strategy_,
-        uint256 assetsNeeded_
-    ) external view returns (uint256) {
-        uint256 currentDebt = _strategies[strategy_].currentDebt;
-        require(currentDebt >= assetsNeeded_, NotEnoughDebt());
-
-        return _assess_share_of_unrealised_losses(strategy_, currentDebt, assetsNeeded_);
-    }
-
     // ============================================
     // VIEW FUNCTIONS - PROFIT LOCKING
     // ============================================

src/core/interfaces/IMultistrategyVault.sol

@@ -349,7 +349,6 @@ interface IMultistrategyVault {
     // NOTE: The following functions are declared for interface completeness where
     // some implementations may expose equivalent public state variables.
     function strategies(address strategy) external view returns (StrategyParams memory);
-    function defaultQueue() external view returns (address[] memory);
     function useDefaultQueue() external view returns (bool);
     function autoAllocate() external view returns (bool);
     function minimumTotalIdle() external view returns (uint256);
@@ -456,8 +455,8 @@ interface IMultistrategyVault {
     ) external returns (bool);
 
     // Management Functions
-    function set_name(string memory name) external;
-    function set_symbol(string memory symbol) external;
+    function setName(string memory name) external;
+    function setSymbol(string memory symbol) external;
     function set_accountant(address newAccountant) external;
     function set_default_queue(address[] memory newDefaultQueue) external;
     function set_use_default_queue(bool useDefaultQueue) external;

test/unit/core/multistrategyvault/QueueManagement.t.sol

@@ -196,7 +196,7 @@ contract QueueManagementTest is Test {
 
     function testAddStrategyAddsToQueue() public {
         // Check empty queue initially
-        address[] memory queue = vault.defaultQueue();
+        address[] memory queue = vault.get_default_queue();
         assertEq(queue.length, 0, "Queue should start empty");
 
         // Add first strategy
@@ -205,7 +205,7 @@ contract QueueManagementTest is Test {
         vault.add_strategy(strategyOne, true);
 
         // Check queue contains the first strategy
-        queue = vault.defaultQueue();
+        queue = vault.get_default_queue();
         assertEq(queue.length, 1, "Queue should have one strategy");
         assertEq(queue[0], strategyOne, "First strategy should be in queue");
 
@@ -215,15 +215,15 @@ contract QueueManagementTest is Test {
         vault.add_strategy(strategyTwo, true);
 
         // Check queue contains both strategies in order
-        queue = vault.defaultQueue();
+        queue = vault.get_default_queue();
         assertEq(queue.length, 2, "Queue should have two strategies");
         assertEq(queue[0], strategyOne, "First strategy should be first in queue");
         assertEq(queue[1], strategyTwo, "Second strategy should be second in queue");
     }
 
     function testAddStrategyDontAddToQueue() public {
         // Check empty queue initially
-        address[] memory queue = vault.defaultQueue();
+        address[] memory queue = vault.get_default_queue();
         assertEq(queue.length, 0, "Queue should start empty");
 
         // Add first strategy without adding to queue
@@ -232,7 +232,7 @@ contract QueueManagementTest is Test {
         vault.add_strategy(strategyOne, false);
 
         // Check queue is still empty
-        queue = vault.defaultQueue();
+        queue = vault.get_default_queue();
         assertEq(queue.length, 0, "Queue should still be empty");
 
         // Check strategy is still active
@@ -245,13 +245,13 @@ contract QueueManagementTest is Test {
         vault.add_strategy(strategyTwo, false);
 
         // Check queue is still empty
-        queue = vault.defaultQueue();
+        queue = vault.get_default_queue();
         assertEq(queue.length, 0, "Queue should still be empty");
     }
 
     function testAddElevenStrategiesAddsTenToQueue() public {
         // Check empty queue initially
-        address[] memory queue = vault.defaultQueue();
+        address[] memory queue = vault.get_default_queue();
         assertEq(queue.length, 0, "Queue should start empty");
 
         // Add 10 strategies and check queue length increases each time
@@ -263,12 +263,12 @@ contract QueueManagementTest is Test {
             vm.prank(gov);
             vault.add_strategy(newStrategy, true);
 
-            queue = vault.defaultQueue();
+            queue = vault.get_default_queue();
             assertEq(queue.length, i + 1, "Queue length should increase");
         }
 
         // Store queue for comparison
-        address[] memory defaultQueue = vault.defaultQueue();
+        address[] memory defaultQueue = vault.get_default_queue();
         assertEq(defaultQueue.length, 10, "Default queue should have 10 strategies");
 
         // Add 11th strategy
@@ -283,7 +283,7 @@ contract QueueManagementTest is Test {
         assertGt(params.activation, 0, "Strategy should be active");
 
         // Check queue remains unchanged
-        address[] memory newQueue = vault.defaultQueue();
+        address[] memory newQueue = vault.get_default_queue();
         assertEq(newQueue.length, 10, "Queue should still have 10 strategies");
 
         // Verify 11th strategy isn't in queue
@@ -299,7 +299,7 @@ contract QueueManagementTest is Test {
 
     function testRevokeStrategyRemovesStrategyFromQueue() public {
         // Check empty queue initially
-        address[] memory queue = vault.defaultQueue();
+        address[] memory queue = vault.get_default_queue();
         assertEq(queue.length, 0, "Queue should start empty");
 
         // Add a strategy
@@ -308,7 +308,7 @@ contract QueueManagementTest is Test {
         vault.add_strategy(strategyOne, true);
 
         // Check queue contains the strategy
-        queue = vault.defaultQueue();
+        queue = vault.get_default_queue();
         assertEq(queue.length, 1, "Queue should have one strategy");
         assertEq(queue[0], strategyOne, "Strategy should be in queue");
 
@@ -320,7 +320,7 @@ contract QueueManagementTest is Test {
         IMultistrategyVault.StrategyParams memory params = vault.strategies(strategyOne);
         assertEq(params.activation, 0, "Strategy should not be active");
 
-        queue = vault.defaultQueue();
+        queue = vault.get_default_queue();
         assertEq(queue.length, 0, "Queue should be empty");
     }
 
@@ -334,7 +334,7 @@ contract QueueManagementTest is Test {
         IMultistrategyVault.StrategyParams memory params = vault.strategies(strategyOne);
         assertGt(params.activation, 0, "Strategy should be active");
 
-        address[] memory queue = vault.defaultQueue();
+        address[] memory queue = vault.get_default_queue();
         assertEq(queue.length, 0, "Queue should be empty");
 
         // Revoke the strategy
@@ -345,7 +345,7 @@ contract QueueManagementTest is Test {
         params = vault.strategies(strategyOne);
         assertEq(params.activation, 0, "Strategy should not be active");
 
-        queue = vault.defaultQueue();
+        queue = vault.get_default_queue();
         assertEq(queue.length, 0, "Queue should still be empty");
     }
 
@@ -360,7 +360,7 @@ contract QueueManagementTest is Test {
         vault.add_strategy(strategyTwo, true);
 
         // Check queue contains both strategies
-        address[] memory queue = vault.defaultQueue();
+        address[] memory queue = vault.get_default_queue();
         assertEq(queue.length, 2, "Queue should have two strategies");
         assertEq(queue[0], strategyOne, "First strategy should be first in queue");
         assertEq(queue[1], strategyTwo, "Second strategy should be second in queue");
@@ -373,7 +373,7 @@ contract QueueManagementTest is Test {
         IMultistrategyVault.StrategyParams memory params = vault.strategies(strategyOne);
         assertEq(params.activation, 0, "First strategy should not be active");
 
-        queue = vault.defaultQueue();
+        queue = vault.get_default_queue();
         assertEq(queue.length, 1, "Queue should have one strategy");
         assertEq(queue[0], strategyTwo, "Only second strategy should be in queue");
     }
@@ -390,7 +390,7 @@ contract QueueManagementTest is Test {
         }
 
         // Store queue for comparison
-        address[] memory defaultQueue = vault.defaultQueue();
+        address[] memory defaultQueue = vault.get_default_queue();
         assertEq(defaultQueue.length, 10, "Default queue should have 10 strategies");
 
         // Add 11th strategy
@@ -407,7 +407,7 @@ contract QueueManagementTest is Test {
         vault.revoke_strategy(eleventhStrategy);
 
         // Check queue is unchanged
-        address[] memory newQueue = vault.defaultQueue();
+        address[] memory newQueue = vault.get_default_queue();
         assertEq(newQueue.length, 10, "Queue should still have 10 strategies");
 
         // Verify queue is unchanged
@@ -427,7 +427,7 @@ contract QueueManagementTest is Test {
         vault.add_strategy(strategyTwo, true);
 
         // Check default queue order
-        address[] memory queue = vault.defaultQueue();
+        address[] memory queue = vault.get_default_queue();
         assertEq(queue.length, 2, "Queue should have two strategies");
         assertEq(queue[0], strategyOne, "First strategy should be first in queue");
         assertEq(queue[1], strategyTwo, "Second strategy should be second in queue");
@@ -443,7 +443,7 @@ contract QueueManagementTest is Test {
         vault.set_default_queue(newQueue);
 
         // Check new queue is set
-        queue = vault.defaultQueue();
+        queue = vault.get_default_queue();
         assertEq(queue.length, 2, "Queue should have two strategies");
         assertEq(queue[0], strategyTwo, "First strategy should now be the second strategy");
         assertEq(queue[1], strategyOne, "Second strategy should now be the first strategy");

test/unit/core/multistrategyvault/RoleBasedAccess.t.sol

@@ -531,15 +531,15 @@ contract RoleBasedAccessTest is Test {
         vault.add_role(bunny, IMultistrategyVault.Roles.QUEUE_MANAGER);
 
         // Get initial queue
-        address[] memory initialQueue = vault.defaultQueue();
+        address[] memory initialQueue = vault.get_default_queue();
         assertGt(initialQueue.length, 0, "Initial queue should not be empty");
 
         // Set default queue with bunny
         vm.prank(bunny);
         vault.set_default_queue(new address[](0));
 
         // Verify new state
-        address[] memory newQueue = vault.defaultQueue();
+        address[] memory newQueue = vault.get_default_queue();
         assertEq(newQueue.length, 0, "Queue should be empty after setting");
     }
 
@@ -729,7 +729,7 @@ contract RoleBasedAccessTest is Test {
         // Verify bunny can't set name
         vm.prank(bunny);
         vm.expectRevert(IMultistrategyVault.NotAllowed.selector);
-        vault.set_name(newName);
+        vault.setName(newName);
 
         // Give bunny ALL roles
         vm.prank(gov);
@@ -738,14 +738,14 @@ contract RoleBasedAccessTest is Test {
         // Verify bunny still can't set name (only roleManager can)
         vm.prank(bunny);
         vm.expectRevert(IMultistrategyVault.NotAllowed.selector);
-        vault.set_name(newName);
+        vault.setName(newName);
 
         // Verify name unchanged
         assertEq(vault.name(), initialName, "Name should be unchanged");
 
         // Set name with gov (roleManager)
         vm.prank(gov);
-        vault.set_name(newName);
+        vault.setName(newName);
 
         // Verify name changed
         assertEq(vault.name(), newName, "Name should be changed");
@@ -760,7 +760,7 @@ contract RoleBasedAccessTest is Test {
         // Verify bunny can't set symbol
         vm.prank(bunny);
         vm.expectRevert(IMultistrategyVault.NotAllowed.selector);
-        vault.set_symbol(newSymbol);
+        vault.setSymbol(newSymbol);
 
         // Give bunny ALL roles
         vm.prank(gov);
@@ -769,14 +769,14 @@ contract RoleBasedAccessTest is Test {
         // Verify bunny still can't set symbol (only roleManager can)
         vm.prank(bunny);
         vm.expectRevert(IMultistrategyVault.NotAllowed.selector);
-        vault.set_symbol(newSymbol);
+        vault.setSymbol(newSymbol);
 
         // Verify symbol unchanged
         assertEq(vault.symbol(), initialSymbol, "Symbol should be unchanged");
 
         // Set symbol with gov (roleManager)
         vm.prank(gov);
-        vault.set_symbol(newSymbol);
+        vault.setSymbol(newSymbol);
 
         // Verify symbol changed
         assertEq(vault.symbol(), newSymbol, "Symbol should be changed");