fix(el): middleware + tests

smart-contracts/src/contracts/EigenLayerMiddlewareV1.sol

@@ -271,11 +271,11 @@ contract EigenLayerMiddlewareV1 is OwnableUpgradeable, UUPSUpgradeable, IAVSRegi
     /// @return The restaked strategy addresses
     function getOperatorRestakedStrategies(
         address operator
-    ) returns (address[] memory) {
+    ) public returns (address[] memory) {
         // Only take strategies that are active at <timestamp>
         IStrategy[] memory activeStrategies = _getActiveStrategiesAt(_now());
 
-        address[] memory collateralTokens = new address[](activeStrategies.length);
+        address[] memory restakedStrategies = new address[](activeStrategies.length);
 
         // get the shares of the operator across all strategies
         uint256[] memory shares = DELEGATION_MANAGER.getOperatorShares(operator, activeStrategies);
@@ -284,14 +284,14 @@ contract EigenLayerMiddlewareV1 is OwnableUpgradeable, UUPSUpgradeable, IAVSRegi
         uint256 restakedCount = 0;
         for (uint256 i = 0; i < activeStrategies.length; i++) {
             if (activeStrategies[i].sharesToUnderlyingView(shares[i]) > 0) {
-                collateralTokens[restakedCount] = address(activeStrategies[i].underlyingToken());
+                restakedStrategies[restakedCount] = address(activeStrategies[i]);
                 restakedCount++;
             }
         }
 
         address[] memory result = new address[](restakedCount);
         for (uint256 i = 0; i < restakedCount; i++) {
-            result[i] = collateralTokens[i];
+            result[i] = restakedStrategies[i];
         }
 
         return result;
@@ -300,8 +300,17 @@ contract EigenLayerMiddlewareV1 is OwnableUpgradeable, UUPSUpgradeable, IAVSRegi
     /// @notice Get the strategies that an operator can restake in
     /// @param operator The operator address to get the restakeable strategies for
     /// @return The restakeable strategy addresses
-    function getRestakeableStrategies() external view returns (address[] memory) {
-        return getActiveWhitelistedStrategies();
+    function getRestakeableStrategies(address operator) public view returns (address[] memory) {
+        // All operators can use all whitelisted, active strategies.
+        IStrategy[] memory strategies = getActiveWhitelistedStrategies();
+
+        // cast to address[] to match the return type
+        address[] memory result = new address[](strategies.length);
+        for (uint256 i = 0; i < strategies.length; i++) {
+            result[i] = address(strategies[i]);
+        }
+
+        return result;
     }
 
     // ========= [post-ELIP-002] IAVSRegistrar functions ========= //

smart-contracts/test/holesky/EigenLayerMiddlewareV1.t.sol

@@ -186,6 +186,18 @@ contract EigenLayerMiddlewareV1Test is Test {
         // weth should have 100e18 balance
         assertEq(collaterals[1], address(holeskyWeth));
         assertEq(amounts[1], 100 ether);
+
+        // Check the operator's restaked strategies
+        address[] memory restakedStrategies = middleware.getOperatorRestakedStrategies(operator);
+        assertEq(restakedStrategies.length, 1);
+        assertEq(restakedStrategies[0], address(holeskyWethStrategy));
+    }
+
+    function testReadRestakeableStrategies() public view {
+        address[] memory strategies = middleware.getRestakeableStrategies(operator);
+        assertEq(strategies.length, 2);
+        assertEq(strategies[0], address(holeskyStEthStrategy));
+        assertEq(strategies[1], address(holeskyWethStrategy));
     }
 
     function testCannotAddAlreadyWhitelistedStrategy() public {
@@ -242,7 +254,7 @@ contract EigenLayerMiddlewareV1Test is Test {
         middleware.updateAllocationManagerAddress(address(0));
 
         // When the AllocationManager is set to 0x0, the only way to opt-in
-        // is through the middeware.registerThroughAVSDirectory() method.
+        // is through the middeware.registerOperatorToAVS() method.
 
         uint32 allocationDelay = 1;
         address delegationApprover = address(0x0); // this is optional, skip it
@@ -276,6 +288,6 @@ contract EigenLayerMiddlewareV1Test is Test {
 
         vm.prank(operator);
         vm.expectRevert(EigenLayerMiddlewareV1.NotOperator.selector);
-        middleware.registerThroughAVSDirectory("http://stopjava.com", "operator1", operatorSignature);
+        middleware.registerOperatorToAVS("http://stopjava.com", "operator1", operatorSignature);
     }
 }

smart-contracts/test/mainnet/EigenLayerMiddlewareV1.t.sol

@@ -140,7 +140,7 @@ contract EigenLayerMiddlewareV1Test is Test {
             ISignatureUtils.SignatureWithSaltAndExpiry(operatorRawSignature, bytes32(0), UINT256_MAX);
 
         vm.prank(signer);
-        middleware.registerThroughAVSDirectory(rpcEndpoint, extraData, operatorSignature);
+        middleware.registerOperatorToAVS(rpcEndpoint, extraData, operatorSignature);
 
         vm.warp(block.timestamp + 1 days);