feat(ServiceProviderRegistry): add getProvidersByIds batch lookup function (#251)

## Summary
Implements `getProvidersByIds` function to enable batch retrieval of
provider information by an array of IDs, addressing the need to
efficiently query multiple providers after getting approved provider IDs
from WASM storage.

## Changes
- **New function**: `getProvidersByIds(uint256[] calldata providerIds)` 
- **Returns**: Array of `ServiceProviderInfoView` structs and
corresponding validity flags
- **Handles invalid IDs**: Returns empty structs with `validIds[i] =
false` for non-existent/inactive providers
- **Gas optimized**: Caches storage reads and uses efficient storage
references
- **Helper function**: `_getEmptyProviderInfoView()` for consistent
empty struct creation

## Use Case
Enables the workflow described in [issue
#232](#232):
1. Call WASM storage `getApprovedProviders` to get list of provider IDs
2. Use same list to batch query service registry for provider info
3. Process results with validity flags to handle any invalid IDs

## Testing
- ✅ Comprehensive test coverage for success cases, invalid IDs, and edge
cases
- ✅ All existing tests pass

```solidity
function getProvidersByIds(uint256[] calldata providerIds)
    external
    view
    returns (ServiceProviderInfoView[] memory providerInfos, bool[] memory validIds)
```

Closes #232

Author: Chaitu-Tatipamula

service_contracts/abi/ServiceProviderRegistry.abi.json

@@ -843,6 +843,69 @@
     ],
     "stateMutability": "view"
   },
+  {
+    "type": "function",
+    "name": "getProvidersByIds",
+    "inputs": [
+      {
+        "name": "providerIds",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "providerInfos",
+        "type": "tuple[]",
+        "internalType": "struct ServiceProviderRegistry.ServiceProviderInfoView[]",
+        "components": [
+          {
+            "name": "providerId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "info",
+            "type": "tuple",
+            "internalType": "struct ServiceProviderRegistryStorage.ServiceProviderInfo",
+            "components": [
+              {
+                "name": "serviceProvider",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "payee",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "name",
+                "type": "string",
+                "internalType": "string"
+              },
+              {
+                "name": "description",
+                "type": "string",
+                "internalType": "string"
+              },
+              {
+                "name": "isActive",
+                "type": "bool",
+                "internalType": "bool"
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "name": "validIds",
+        "type": "bool[]",
+        "internalType": "bool[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
   {
     "type": "function",
     "name": "getProvidersByProductType",

service_contracts/src/ServiceProviderRegistry.sol

@@ -647,16 +647,7 @@ contract ServiceProviderRegistry is
     {
         uint256 providerId = addressToProviderId[providerAddress];
         if (providerId == 0) {
-            return ServiceProviderInfoView({
-                providerId: 0,
-                info: ServiceProviderInfo({
-                    serviceProvider: address(0),
-                    payee: address(0),
-                    name: "",
-                    description: "",
-                    isActive: false
-                })
-            });
+            return _getEmptyProviderInfoView();
         }
 
         ServiceProviderInfo storage provider = providers[providerId];
@@ -715,6 +706,56 @@ contract ServiceProviderRegistry is
         }
     }
 
+    /// @notice Get multiple providers by their IDs
+    /// @param providerIds Array of provider IDs to retrieve
+    /// @return providerInfos Array of provider information corresponding to the input IDs
+    /// @return validIds Array of booleans indicating whether each ID is valid (exists and is active)
+    /// @dev Returns empty ServiceProviderInfoView structs for invalid IDs, with corresponding validIds[i] = false
+    function getProvidersByIds(uint256[] calldata providerIds)
+        external
+        view
+        returns (ServiceProviderInfoView[] memory providerInfos, bool[] memory validIds)
+    {
+        uint256 length = providerIds.length;
+        providerInfos = new ServiceProviderInfoView[](length);
+        validIds = new bool[](length);
+
+        uint256 _numProviders = numProviders;
+
+        for (uint256 i = 0; i < length; i++) {
+            uint256 providerId = providerIds[i];
+
+            if (providerId > 0 && providerId <= _numProviders) {
+                ServiceProviderInfo storage provider = providers[providerId];
+                if (provider.serviceProvider != address(0) && provider.isActive) {
+                    providerInfos[i] = ServiceProviderInfoView({providerId: providerId, info: provider});
+                    validIds[i] = true;
+                } else {
+                    providerInfos[i] = _getEmptyProviderInfoView();
+                    validIds[i] = false;
+                }
+            } else {
+                providerInfos[i] = _getEmptyProviderInfoView();
+                validIds[i] = false;
+            }
+        }
+    }
+
+    /// @notice Internal helper to create an empty ServiceProviderInfoView
+    /// @return Empty ServiceProviderInfoView struct
+    function _getEmptyProviderInfoView() internal pure returns (ServiceProviderInfoView memory) {
+        return ServiceProviderInfoView({
+            providerId: 0,
+            info: ServiceProviderInfo({
+                serviceProvider: address(0),
+                payee: address(0),
+                name: "",
+                description: "",
+                isActive: false
+            })
+        });
+    }
+
     /// @notice Get total number of registered providers (including inactive)
     /// @return The total count of providers
     function getProviderCount() external view returns (uint256) {

service_contracts/test/ServiceProviderRegistry.t.sol

@@ -359,4 +359,210 @@ contract ServiceProviderRegistryTest is Test {
         vm.expectRevert("Provider does not exist");
         registry.getProviderPayee(1);
     }
+
+    // ========== Tests for getProvidersByIds ==========
+
+    function testGetProvidersByIdsEmptyArray() public {
+        uint256[] memory emptyIds = new uint256[](0);
+
+        (ServiceProviderRegistry.ServiceProviderInfoView[] memory providerInfos, bool[] memory validIds) =
+            registry.getProvidersByIds(emptyIds);
+
+        assertEq(providerInfos.length, 0, "Should return empty array for empty input");
+        assertEq(validIds.length, 0, "Should return empty validIds array for empty input");
+    }
+
+    function testGetProvidersByIdsSingleValidProvider() public {
+        // Register a provider first
+        vm.deal(user1, 10 ether);
+        vm.prank(user1);
+        uint256 providerId = registry.registerProvider{value: 5 ether}(
+            user1,
+            "Test Provider",
+            "Test Description",
+            ServiceProviderRegistryStorage.ProductType.PDP,
+            _createValidPDPOffering(),
+            new string[](0),
+            new string[](0)
+        );
+
+        uint256[] memory ids = new uint256[](1);
+        ids[0] = providerId;
+
+        (ServiceProviderRegistry.ServiceProviderInfoView[] memory providerInfos, bool[] memory validIds) =
+            registry.getProvidersByIds(ids);
+
+        assertEq(providerInfos.length, 1, "Should return one provider");
+        assertEq(validIds.length, 1, "Should return one validity flag");
+        assertTrue(validIds[0], "Provider should be valid");
+        assertEq(providerInfos[0].providerId, providerId, "Provider ID should match");
+        assertEq(providerInfos[0].info.serviceProvider, user1, "Service provider address should match");
+        assertEq(providerInfos[0].info.name, "Test Provider", "Provider name should match");
+        assertEq(providerInfos[0].info.description, "Test Description", "Provider description should match");
+        assertTrue(providerInfos[0].info.isActive, "Provider should be active");
+    }
+
+    function testGetProvidersByIdsMultipleValidProviders() public {
+        // Register multiple providers
+        vm.deal(user1, 10 ether);
+        vm.deal(user2, 10 ether);
+
+        vm.prank(user1);
+        uint256 providerId1 = registry.registerProvider{value: 5 ether}(
+            user1,
+            "Provider 1",
+            "Description 1",
+            ServiceProviderRegistryStorage.ProductType.PDP,
+            _createValidPDPOffering(),
+            new string[](0),
+            new string[](0)
+        );
+
+        vm.prank(user2);
+        uint256 providerId2 = registry.registerProvider{value: 5 ether}(
+            user2,
+            "Provider 2",
+            "Description 2",
+            ServiceProviderRegistryStorage.ProductType.PDP,
+            _createValidPDPOffering(),
+            new string[](0),
+            new string[](0)
+        );
+
+        uint256[] memory ids = new uint256[](2);
+        ids[0] = providerId1;
+        ids[1] = providerId2;
+
+        (ServiceProviderRegistry.ServiceProviderInfoView[] memory providerInfos, bool[] memory validIds) =
+            registry.getProvidersByIds(ids);
+
+        assertEq(providerInfos.length, 2, "Should return two providers");
+        assertEq(validIds.length, 2, "Should return two validity flags");
+
+        // Check first provider
+        assertTrue(validIds[0], "First provider should be valid");
+        assertEq(providerInfos[0].providerId, providerId1, "First provider ID should match");
+        assertEq(providerInfos[0].info.serviceProvider, user1, "First provider address should match");
+        assertEq(providerInfos[0].info.name, "Provider 1", "First provider name should match");
+
+        // Check second provider
+        assertTrue(validIds[1], "Second provider should be valid");
+        assertEq(providerInfos[1].providerId, providerId2, "Second provider ID should match");
+        assertEq(providerInfos[1].info.serviceProvider, user2, "Second provider address should match");
+        assertEq(providerInfos[1].info.name, "Provider 2", "Second provider name should match");
+    }
+
+    function testGetProvidersByIdsInvalidIds() public {
+        uint256[] memory ids = new uint256[](3);
+        ids[0] = 0; // Invalid ID (0)
+        ids[1] = 999; // Non-existent ID
+        ids[2] = 1; // Valid ID but no provider registered yet
+
+        (ServiceProviderRegistry.ServiceProviderInfoView[] memory providerInfos, bool[] memory validIds) =
+            registry.getProvidersByIds(ids);
+
+        assertEq(providerInfos.length, 3, "Should return three results");
+        assertEq(validIds.length, 3, "Should return three validity flags");
+
+        // All should be invalid
+        assertFalse(validIds[0], "ID 0 should be invalid");
+        assertFalse(validIds[1], "Non-existent ID should be invalid");
+        assertFalse(validIds[2], "Unregistered ID should be invalid");
+
+        // All should have empty structs
+        for (uint256 i = 0; i < 3; i++) {
+            assertEq(providerInfos[i].info.serviceProvider, address(0), "Invalid provider should have zero address");
+            assertEq(providerInfos[i].providerId, 0, "Invalid provider should have zero ID");
+            assertFalse(providerInfos[i].info.isActive, "Invalid provider should be inactive");
+        }
+    }
+
+    function testGetProvidersByIdsMixedValidAndInvalid() public {
+        // Register one provider
+        vm.deal(user1, 10 ether);
+        vm.prank(user1);
+        uint256 validProviderId = registry.registerProvider{value: 5 ether}(
+            user1,
+            "Valid Provider",
+            "Valid Description",
+            ServiceProviderRegistryStorage.ProductType.PDP,
+            _createValidPDPOffering(),
+            new string[](0),
+            new string[](0)
+        );
+
+        uint256[] memory ids = new uint256[](4);
+        ids[0] = validProviderId; // Valid
+        ids[1] = 0; // Invalid
+        ids[2] = 999; // Invalid
+        ids[3] = validProviderId; // Valid (duplicate)
+
+        (ServiceProviderRegistry.ServiceProviderInfoView[] memory providerInfos, bool[] memory validIds) =
+            registry.getProvidersByIds(ids);
+
+        assertEq(providerInfos.length, 4, "Should return four results");
+        assertEq(validIds.length, 4, "Should return four validity flags");
+
+        // Check valid providers
+        assertTrue(validIds[0], "First provider should be valid");
+        assertEq(providerInfos[0].providerId, validProviderId, "First provider ID should match");
+        assertEq(providerInfos[0].info.serviceProvider, user1, "First provider address should match");
+
+        // Check invalid providers
+        assertFalse(validIds[1], "Second provider should be invalid");
+        assertFalse(validIds[2], "Third provider should be invalid");
+
+        // Check duplicate valid provider
+        assertTrue(validIds[3], "Fourth provider should be valid");
+        assertEq(providerInfos[3].providerId, validProviderId, "Fourth provider ID should match");
+        assertEq(providerInfos[3].info.serviceProvider, user1, "Fourth provider address should match");
+    }
+
+    function testGetProvidersByIdsInactiveProvider() public {
+        // Register a provider
+        vm.deal(user1, 10 ether);
+        vm.prank(user1);
+        uint256 providerId = registry.registerProvider{value: 5 ether}(
+            user1,
+            "Test Provider",
+            "Test Description",
+            ServiceProviderRegistryStorage.ProductType.PDP,
+            _createValidPDPOffering(),
+            new string[](0),
+            new string[](0)
+        );
+
+        // Remove the provider (make it inactive)
+        vm.prank(user1);
+        registry.removeProvider();
+
+        uint256[] memory ids = new uint256[](1);
+        ids[0] = providerId;
+
+        (ServiceProviderRegistry.ServiceProviderInfoView[] memory providerInfos, bool[] memory validIds) =
+            registry.getProvidersByIds(ids);
+
+        assertEq(providerInfos.length, 1, "Should return one result");
+        assertEq(validIds.length, 1, "Should return one validity flag");
+        assertFalse(validIds[0], "Inactive provider should be invalid");
+        assertEq(providerInfos[0].info.serviceProvider, address(0), "Inactive provider should have zero address");
+        assertEq(providerInfos[0].providerId, 0, "Inactive provider should have zero ID");
+        assertFalse(providerInfos[0].info.isActive, "Inactive provider should be inactive");
+    }
+
+    // Helper function to create a valid PDP offering for tests
+    function _createValidPDPOffering() internal pure returns (bytes memory) {
+        ServiceProviderRegistryStorage.PDPOffering memory pdpOffering = ServiceProviderRegistryStorage.PDPOffering({
+            serviceURL: "https://example.com/api",
+            minPieceSizeInBytes: 1024,
+            maxPieceSizeInBytes: 1024 * 1024,
+            ipniPiece: true,
+            ipniIpfs: true,
+            storagePricePerTibPerMonth: 1000,
+            minProvingPeriodInEpochs: 1,
+            location: "US",
+            paymentTokenAddress: IERC20(address(0))
+        });
+        return abi.encode(pdpOffering);
+    }
 }