fix: resolve rebase conflicts and integrate getProvidersByIds from main

Resolves conflicts after rebasing onto main by:
- Adding new getProvidersByIds() function to ServiceProviderRegistry
- Adding _getEmptyProviderInfoView() helper function
- Updating getProviderByAddress() to use helper function
- Adding comprehensive tests for getProvidersByIds
- Setting pyth-sdk-solidity to correct commit (11d6bcf)

All tests passing including 6 new tests for getProvidersByIds.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: jennijuju

service_contracts/lib/pyth-sdk-solidity

@@ -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/src/service-provider/ServiceProviderRegistry.sol

@@ -359,4 +359,209 @@ 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");
+
+        assertFalse(validIds[0], "Zero ID 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);
+    }
 }