Skip to content

Commit 594a30b

Browse files
jennijujuclaude
jennijuju
and
claude
committed
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 <noreply@anthropic.com>
1 parent f50e196 commit 594a30b

File tree

3 files changed

+257
-11
lines changed

3 files changed

+257
-11
lines changed

‎service_contracts/lib/pyth-sdk-solidity‎

‎service_contracts/src/service-provider/ServiceProviderRegistry.sol‎

Lines changed: 51 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -647,16 +647,7 @@ contract ServiceProviderRegistry is
647647
{
648648
uint256 providerId = addressToProviderId[providerAddress];
649649
if (providerId == 0) {
650-
return ServiceProviderInfoView({
651-
providerId: 0,
652-
info: ServiceProviderInfo({
653-
serviceProvider: address(0),
654-
payee: address(0),
655-
name: "",
656-
description: "",
657-
isActive: false
658-
})
659-
});
650+
return _getEmptyProviderInfoView();
660651
}
661652

662653
ServiceProviderInfo storage provider = providers[providerId];
@@ -715,6 +706,56 @@ contract ServiceProviderRegistry is
715706
}
716707
}
717708

709+
/// @notice Get multiple providers by their IDs
710+
/// @param providerIds Array of provider IDs to retrieve
711+
/// @return providerInfos Array of provider information corresponding to the input IDs
712+
/// @return validIds Array of booleans indicating whether each ID is valid (exists and is active)
713+
/// @dev Returns empty ServiceProviderInfoView structs for invalid IDs, with corresponding validIds[i] = false
714+
function getProvidersByIds(uint256[] calldata providerIds)
715+
external
716+
view
717+
returns (ServiceProviderInfoView[] memory providerInfos, bool[] memory validIds)
718+
{
719+
uint256 length = providerIds.length;
720+
providerInfos = new ServiceProviderInfoView[](length);
721+
validIds = new bool[](length);
722+
723+
uint256 _numProviders = numProviders;
724+
725+
for (uint256 i = 0; i < length; i++) {
726+
uint256 providerId = providerIds[i];
727+
728+
if (providerId > 0 && providerId <= _numProviders) {
729+
ServiceProviderInfo storage provider = providers[providerId];
730+
if (provider.serviceProvider != address(0) && provider.isActive) {
731+
providerInfos[i] = ServiceProviderInfoView({providerId: providerId, info: provider});
732+
validIds[i] = true;
733+
} else {
734+
providerInfos[i] = _getEmptyProviderInfoView();
735+
validIds[i] = false;
736+
}
737+
} else {
738+
providerInfos[i] = _getEmptyProviderInfoView();
739+
validIds[i] = false;
740+
}
741+
}
742+
}
743+
744+
/// @notice Internal helper to create an empty ServiceProviderInfoView
745+
/// @return Empty ServiceProviderInfoView struct
746+
function _getEmptyProviderInfoView() internal pure returns (ServiceProviderInfoView memory) {
747+
return ServiceProviderInfoView({
748+
providerId: 0,
749+
info: ServiceProviderInfo({
750+
serviceProvider: address(0),
751+
payee: address(0),
752+
name: "",
753+
description: "",
754+
isActive: false
755+
})
756+
});
757+
}
758+
718759
/// @notice Get total number of registered providers (including inactive)
719760
/// @return The total count of providers
720761
function getProviderCount() external view returns (uint256) {

‎service_contracts/test/service-provider/ServiceProviderRegistry.t.sol‎

Lines changed: 205 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -359,4 +359,209 @@ contract ServiceProviderRegistryTest is Test {
359359
vm.expectRevert("Provider does not exist");
360360
registry.getProviderPayee(1);
361361
}
362+
363+
// ========== Tests for getProvidersByIds ==========
364+
365+
function testGetProvidersByIdsEmptyArray() public {
366+
uint256[] memory emptyIds = new uint256[](0);
367+
368+
(ServiceProviderRegistry.ServiceProviderInfoView[] memory providerInfos, bool[] memory validIds) =
369+
registry.getProvidersByIds(emptyIds);
370+
371+
assertEq(providerInfos.length, 0, "Should return empty array for empty input");
372+
assertEq(validIds.length, 0, "Should return empty validIds array for empty input");
373+
}
374+
375+
function testGetProvidersByIdsSingleValidProvider() public {
376+
// Register a provider first
377+
vm.deal(user1, 10 ether);
378+
vm.prank(user1);
379+
uint256 providerId = registry.registerProvider{value: 5 ether}(
380+
user1,
381+
"Test Provider",
382+
"Test Description",
383+
ServiceProviderRegistryStorage.ProductType.PDP,
384+
_createValidPDPOffering(),
385+
new string[](0),
386+
new string[](0)
387+
);
388+
389+
uint256[] memory ids = new uint256[](1);
390+
ids[0] = providerId;
391+
392+
(ServiceProviderRegistry.ServiceProviderInfoView[] memory providerInfos, bool[] memory validIds) =
393+
registry.getProvidersByIds(ids);
394+
395+
assertEq(providerInfos.length, 1, "Should return one provider");
396+
assertEq(validIds.length, 1, "Should return one validity flag");
397+
assertTrue(validIds[0], "Provider should be valid");
398+
assertEq(providerInfos[0].providerId, providerId, "Provider ID should match");
399+
assertEq(providerInfos[0].info.serviceProvider, user1, "Service provider address should match");
400+
assertEq(providerInfos[0].info.name, "Test Provider", "Provider name should match");
401+
assertEq(providerInfos[0].info.description, "Test Description", "Provider description should match");
402+
assertTrue(providerInfos[0].info.isActive, "Provider should be active");
403+
}
404+
405+
function testGetProvidersByIdsMultipleValidProviders() public {
406+
// Register multiple providers
407+
vm.deal(user1, 10 ether);
408+
vm.deal(user2, 10 ether);
409+
410+
vm.prank(user1);
411+
uint256 providerId1 = registry.registerProvider{value: 5 ether}(
412+
user1,
413+
"Provider 1",
414+
"Description 1",
415+
ServiceProviderRegistryStorage.ProductType.PDP,
416+
_createValidPDPOffering(),
417+
new string[](0),
418+
new string[](0)
419+
);
420+
421+
vm.prank(user2);
422+
uint256 providerId2 = registry.registerProvider{value: 5 ether}(
423+
user2,
424+
"Provider 2",
425+
"Description 2",
426+
ServiceProviderRegistryStorage.ProductType.PDP,
427+
_createValidPDPOffering(),
428+
new string[](0),
429+
new string[](0)
430+
);
431+
432+
uint256[] memory ids = new uint256[](2);
433+
ids[0] = providerId1;
434+
ids[1] = providerId2;
435+
436+
(ServiceProviderRegistry.ServiceProviderInfoView[] memory providerInfos, bool[] memory validIds) =
437+
registry.getProvidersByIds(ids);
438+
439+
assertEq(providerInfos.length, 2, "Should return two providers");
440+
assertEq(validIds.length, 2, "Should return two validity flags");
441+
442+
// Check first provider
443+
assertTrue(validIds[0], "First provider should be valid");
444+
assertEq(providerInfos[0].providerId, providerId1, "First provider ID should match");
445+
assertEq(providerInfos[0].info.serviceProvider, user1, "First provider address should match");
446+
assertEq(providerInfos[0].info.name, "Provider 1", "First provider name should match");
447+
448+
// Check second provider
449+
assertTrue(validIds[1], "Second provider should be valid");
450+
assertEq(providerInfos[1].providerId, providerId2, "Second provider ID should match");
451+
assertEq(providerInfos[1].info.serviceProvider, user2, "Second provider address should match");
452+
assertEq(providerInfos[1].info.name, "Provider 2", "Second provider name should match");
453+
}
454+
455+
function testGetProvidersByIdsInvalidIds() public {
456+
uint256[] memory ids = new uint256[](3);
457+
ids[0] = 0; // Invalid ID (0)
458+
ids[1] = 999; // Non-existent ID
459+
ids[2] = 1; // Valid ID but no provider registered yet
460+
461+
(ServiceProviderRegistry.ServiceProviderInfoView[] memory providerInfos, bool[] memory validIds) =
462+
registry.getProvidersByIds(ids);
463+
464+
assertEq(providerInfos.length, 3, "Should return three results");
465+
assertEq(validIds.length, 3, "Should return three validity flags");
466+
467+
assertFalse(validIds[0], "Zero ID should be invalid");
468+
assertFalse(validIds[1], "Non-existent ID should be invalid");
469+
assertFalse(validIds[2], "Unregistered ID should be invalid");
470+
471+
// All should have empty structs
472+
for (uint256 i = 0; i < 3; i++) {
473+
assertEq(providerInfos[i].info.serviceProvider, address(0), "Invalid provider should have zero address");
474+
assertEq(providerInfos[i].providerId, 0, "Invalid provider should have zero ID");
475+
assertFalse(providerInfos[i].info.isActive, "Invalid provider should be inactive");
476+
}
477+
}
478+
479+
function testGetProvidersByIdsMixedValidAndInvalid() public {
480+
// Register one provider
481+
vm.deal(user1, 10 ether);
482+
vm.prank(user1);
483+
uint256 validProviderId = registry.registerProvider{value: 5 ether}(
484+
user1,
485+
"Valid Provider",
486+
"Valid Description",
487+
ServiceProviderRegistryStorage.ProductType.PDP,
488+
_createValidPDPOffering(),
489+
new string[](0),
490+
new string[](0)
491+
);
492+
493+
uint256[] memory ids = new uint256[](4);
494+
ids[0] = validProviderId; // Valid
495+
ids[1] = 0; // Invalid
496+
ids[2] = 999; // Invalid
497+
ids[3] = validProviderId; // Valid (duplicate)
498+
499+
(ServiceProviderRegistry.ServiceProviderInfoView[] memory providerInfos, bool[] memory validIds) =
500+
registry.getProvidersByIds(ids);
501+
502+
assertEq(providerInfos.length, 4, "Should return four results");
503+
assertEq(validIds.length, 4, "Should return four validity flags");
504+
505+
// Check valid providers
506+
assertTrue(validIds[0], "First provider should be valid");
507+
assertEq(providerInfos[0].providerId, validProviderId, "First provider ID should match");
508+
assertEq(providerInfos[0].info.serviceProvider, user1, "First provider address should match");
509+
510+
// Check invalid providers
511+
assertFalse(validIds[1], "Second provider should be invalid");
512+
assertFalse(validIds[2], "Third provider should be invalid");
513+
514+
// Check duplicate valid provider
515+
assertTrue(validIds[3], "Fourth provider should be valid");
516+
assertEq(providerInfos[3].providerId, validProviderId, "Fourth provider ID should match");
517+
assertEq(providerInfos[3].info.serviceProvider, user1, "Fourth provider address should match");
518+
}
519+
520+
function testGetProvidersByIdsInactiveProvider() public {
521+
// Register a provider
522+
vm.deal(user1, 10 ether);
523+
vm.prank(user1);
524+
uint256 providerId = registry.registerProvider{value: 5 ether}(
525+
user1,
526+
"Test Provider",
527+
"Test Description",
528+
ServiceProviderRegistryStorage.ProductType.PDP,
529+
_createValidPDPOffering(),
530+
new string[](0),
531+
new string[](0)
532+
);
533+
534+
// Remove the provider (make it inactive)
535+
vm.prank(user1);
536+
registry.removeProvider();
537+
538+
uint256[] memory ids = new uint256[](1);
539+
ids[0] = providerId;
540+
541+
(ServiceProviderRegistry.ServiceProviderInfoView[] memory providerInfos, bool[] memory validIds) =
542+
registry.getProvidersByIds(ids);
543+
544+
assertEq(providerInfos.length, 1, "Should return one result");
545+
assertEq(validIds.length, 1, "Should return one validity flag");
546+
assertFalse(validIds[0], "Inactive provider should be invalid");
547+
assertEq(providerInfos[0].info.serviceProvider, address(0), "Inactive provider should have zero address");
548+
assertEq(providerInfos[0].providerId, 0, "Inactive provider should have zero ID");
549+
assertFalse(providerInfos[0].info.isActive, "Inactive provider should be inactive");
550+
}
551+
552+
// Helper function to create a valid PDP offering for tests
553+
function _createValidPDPOffering() internal pure returns (bytes memory) {
554+
ServiceProviderRegistryStorage.PDPOffering memory pdpOffering = ServiceProviderRegistryStorage.PDPOffering({
555+
serviceURL: "https://example.com/api",
556+
minPieceSizeInBytes: 1024,
557+
maxPieceSizeInBytes: 1024 * 1024,
558+
ipniPiece: true,
559+
ipniIpfs: true,
560+
storagePricePerTibPerMonth: 1000,
561+
minProvingPeriodInEpochs: 1,
562+
location: "US",
563+
paymentTokenAddress: IERC20(address(0))
564+
});
565+
return abi.encode(pdpOffering);
566+
}
362567
}

0 commit comments

Comments
 (0)