perf!(ServiceProviderRegistry): Bloom Schema

service_contracts/abi/ServiceProviderRegistryStorage.abi.json

@@ -73,8 +73,8 @@
     "outputs": [
       {
         "name": "value",
-        "type": "string",
-        "internalType": "string"
+        "type": "bytes",
+        "internalType": "bytes"
       }
     ],
     "stateMutability": "view"
@@ -119,11 +119,6 @@
         "type": "uint8",
         "internalType": "enum ServiceProviderRegistryStorage.ProductType"
       },
-      {
-        "name": "productData",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
       {
         "name": "isActive",
         "type": "bool",

service_contracts/src/Errors.sol

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 pragma solidity ^0.8.27;
 
+import {ServiceProviderRegistryStorage} from "./ServiceProviderRegistryStorage.sol";
+
 /// @title Errors
 /// @notice Centralized library for custom error definitions across the protocol
 library Errors {
@@ -286,4 +288,8 @@ library Errors {
     /// @param dataSetId The data set ID
     /// @param pdpEndEpoch The end epoch when the PDP payment rail will finalize
     error PaymentRailsNotFinalized(uint256 dataSetId, uint256 pdpEndEpoch);
+
+    /// @notice The supplied capability keys did not contain all of the required keys for the product type
+    /// @param productType The kind of service product attempted to be registered
+    error InsufficientCapabilitiesForProduct(ServiceProviderRegistryStorage.ProductType productType);
 }

service_contracts/src/ServiceProviderRegistryStorage.sol

@@ -1,8 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 pragma solidity ^0.8.20;
 
-import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-
 /// @title ServiceProviderRegistryStorage
 /// @notice Centralized storage contract for ServiceProviderRegistry
 /// @dev All storage variables are declared here to prevent storage slot collisions during upgrades
@@ -28,29 +26,16 @@ contract ServiceProviderRegistryStorage {
     /// @notice Product offering of the Service Provider
     struct ServiceProduct {
         ProductType productType;
-        bytes productData; // ABI-encoded service-specific data
         string[] capabilityKeys; // Max MAX_CAPABILITY_KEY_LENGTH chars each
         bool isActive;
     }
 
-    /// @notice PDP-specific service data
-    struct PDPOffering {
-        string serviceURL; // HTTP API endpoint
-        uint256 minPieceSizeInBytes; // Minimum piece size accepted in bytes
-        uint256 maxPieceSizeInBytes; // Maximum piece size accepted in bytes
-        bool ipniPiece; // Supports IPNI piece CID indexing
-        bool ipniIpfs; // Supports IPNI IPFS CID indexing
-        uint256 storagePricePerTibPerMonth; // Storage price per TiB per month (in token's smallest unit)
-        uint256 minProvingPeriodInEpochs; // Minimum proving period in epochs
-        string location; // Geographic location of the service provider
-        IERC20 paymentTokenAddress; // Token contract for payment (IERC20(address(0)) for FIL)
-    }
-
     /// @notice Combined provider and product information for detailed queries
     struct ProviderWithProduct {
         uint256 providerId;
         ServiceProviderInfo providerInfo;
         ServiceProduct product;
+        bytes[] productCapabilityValues;
     }
 
     /// @notice Paginated result for provider queries
@@ -75,7 +60,7 @@ contract ServiceProviderRegistryStorage {
     mapping(address providerAddress => uint256 providerId) public addressToProviderId;
 
     /// @notice Capability values mapping for efficient lookups
-    mapping(uint256 providerId => mapping(ProductType productType => mapping(string key => string value))) public
+    mapping(uint256 providerId => mapping(ProductType productType => mapping(string key => bytes value))) public
         productCapabilities;
 
     /// @notice Count of providers (including inactive) offering each product type

service_contracts/src/lib/BloomSet.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+pragma solidity ^0.8.30;
+
+/// @notice Bloom Filter with fixed params:
+/// @notice k = 16 bits per item
+/// @notice m = 256 bits per set
+/// @dev probability of false positives by number of items: (via https://hur.st/bloomfilter/?m=256&k=16)
+/// @dev  7: 0.000000062
+/// @dev  8: 0.00000033
+/// @dev  9: 0.000001377
+/// @dev 10: 0.000004735
+/// @dev 11: 0.000013933
+/// @dev 12: 0.000036084
+/// @dev 13: 0.000084014
+/// @dev 14: 0.000178789
+/// @dev 15: 0.000352341
+library BloomSet16 {
+    uint256 private constant K = 16;
+    uint256 internal constant EMPTY = 0;
+
+    function compressed(string memory uncompressed) internal pure returns (uint256 item) {
+        uint256 hash;
+        assembly ("memory-safe") {
+            hash := keccak256(add(32, uncompressed), mload(uncompressed))
+            item := 0
+        }
+        for (uint256 i = 0; i < K; i++) {
+            item |= 1 << (hash & 0xff);
+            hash >>= 8;
+        }
+    }
+
+    /// @notice Checks if set probably contains the items
+    /// @return false when the set is definitely missing at least one of the items
+    function mayContain(uint256 set, uint256 items) internal pure returns (bool) {
+        return set & items == items;
+    }
+}

service_contracts/test/BloomSet.t.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+pragma solidity ^0.8.30;
+
+import {Test} from "forge-std/Test.sol";
+import {BloomSet16} from "../src/lib/BloomSet.sol";
+
+contract BloomSetTest is Test {
+    using BloomSet16 for string;
+    using BloomSet16 for uint256;
+
+    function testIdentical() public pure {
+        uint256 set = BloomSet16.EMPTY;
+        assertTrue(set.mayContain(BloomSet16.EMPTY));
+        string[] memory same = new string[](6);
+        for (uint256 i = 0; i < same.length; i++) {
+            same[i] = "theVerySame";
+        }
+        for (uint256 i = 0; i < same.length; i++) {
+            set |= same[i].compressed();
+        }
+        assertTrue(set.mayContain(BloomSet16.EMPTY));
+        assertTrue(set.mayContain(set));
+        string memory verySame = "theVerySame";
+        assertEq(set, verySame.compressed());
+        assertTrue(set.mayContain(verySame.compressed()));
+        string memory fromCat = string.concat(string.concat("the", "Very"), "Same");
+        assertEq(verySame.compressed(), fromCat.compressed());
+    }
+
+    function testDifferent() public pure {
+        uint256 set = BloomSet16.EMPTY;
+        string memory one = "1";
+        string memory two = "2";
+        string memory three = "3";
+        set |= one.compressed();
+        assertTrue(set.mayContain(one.compressed()));
+        assertFalse(set.mayContain(two.compressed()));
+        assertFalse(set.mayContain(three.compressed()));
+        set |= two.compressed();
+        assertTrue(set.mayContain(BloomSet16.EMPTY));
+        assertTrue(set.mayContain(one.compressed()));
+        assertTrue(set.mayContain(two.compressed()));
+        assertFalse(set.mayContain(three.compressed()));
+        assertFalse(one.compressed().mayContain(set));
+        assertFalse(two.compressed().mayContain(set));
+        assertFalse(three.compressed().mayContain(set));
+        assertFalse(BloomSet16.EMPTY.mayContain(set));
+        assertFalse(BloomSet16.EMPTY.mayContain(one.compressed()));
+        assertFalse(BloomSet16.EMPTY.mayContain(two.compressed()));
+        assertFalse(BloomSet16.EMPTY.mayContain(three.compressed()));
+    }
+}

service_contracts/test/FilecoinWarmStorageService.t.sol

@@ -19,11 +19,13 @@ import {MockERC20, MockPDPVerifier} from "./mocks/SharedMocks.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {Errors} from "../src/Errors.sol";
 
+import {PDPOffering} from "./PDPOffering.sol";
 import {ServiceProviderRegistryStorage} from "../src/ServiceProviderRegistryStorage.sol";
 import {ServiceProviderRegistry} from "../src/ServiceProviderRegistry.sol";
 
 contract FilecoinWarmStorageServiceTest is MockFVMTest {
     using SafeERC20 for MockERC20;
+    using PDPOffering for PDPOffering.Schema;
     using FilecoinWarmStorageServiceStateLibrary for FilecoinWarmStorageService;
     // Testing Constants
 
@@ -134,97 +136,61 @@ contract FilecoinWarmStorageServiceTest is MockFVMTest {
         MyERC1967Proxy registryProxy = new MyERC1967Proxy(address(registryImpl), registryInitData);
         serviceProviderRegistry = ServiceProviderRegistry(address(registryProxy));
 
+        PDPOffering.Schema memory pdpData = PDPOffering.Schema({
+            serviceURL: "https://provider.com",
+            minPieceSizeInBytes: 1024,
+            maxPieceSizeInBytes: 1024 * 1024,
+            ipniPiece: true,
+            ipniIpfs: false,
+            storagePricePerTibPerDay: 1 ether,
+            minProvingPeriodInEpochs: 2880,
+            location: "US-Central",
+            paymentTokenAddress: IERC20(address(0)) // Payment in FIL
+        });
+        (string[] memory keys, bytes[] memory values) = pdpData.toCapabilities();
+
         // Register service providers in the serviceProviderRegistry
         vm.prank(serviceProvider);
         serviceProviderRegistry.registerProvider{value: 5 ether}(
             serviceProvider, // payee
             "Service Provider",
             "Service Provider Description",
             ServiceProviderRegistryStorage.ProductType.PDP,
-            abi.encode(
-                ServiceProviderRegistryStorage.PDPOffering({
-                    serviceURL: "https://provider.com",
-                    minPieceSizeInBytes: 1024,
-                    maxPieceSizeInBytes: 1024 * 1024,
-                    ipniPiece: true,
-                    ipniIpfs: false,
-                    storagePricePerTibPerMonth: 1 ether,
-                    minProvingPeriodInEpochs: 2880,
-                    location: "US-Central",
-                    paymentTokenAddress: IERC20(address(0)) // Payment in FIL
-                })
-            ),
-            new string[](0),
-            new string[](0)
+            keys,
+            values
         );
 
+        values[0] = bytes("https://sp1.com");
         vm.prank(sp1);
         serviceProviderRegistry.registerProvider{value: 5 ether}(
             sp1, // payee
             "SP1",
             "Storage Provider 1",
             ServiceProviderRegistryStorage.ProductType.PDP,
-            abi.encode(
-                ServiceProviderRegistryStorage.PDPOffering({
-                    serviceURL: "https://sp1.com",
-                    minPieceSizeInBytes: 1024,
-                    maxPieceSizeInBytes: 1024 * 1024,
-                    ipniPiece: true,
-                    ipniIpfs: false,
-                    storagePricePerTibPerMonth: 1 ether,
-                    minProvingPeriodInEpochs: 2880,
-                    location: "US-Central",
-                    paymentTokenAddress: IERC20(address(0)) // Payment in FIL
-                })
-            ),
-            new string[](0),
-            new string[](0)
+            keys,
+            values
         );
 
+        values[0] = bytes("https://sp2.com");
         vm.prank(sp2);
         serviceProviderRegistry.registerProvider{value: 5 ether}(
             sp2, // payee
             "SP2",
             "Storage Provider 2",
             ServiceProviderRegistryStorage.ProductType.PDP,
-            abi.encode(
-                ServiceProviderRegistryStorage.PDPOffering({
-                    serviceURL: "https://sp2.com",
-                    minPieceSizeInBytes: 1024,
-                    maxPieceSizeInBytes: 1024 * 1024,
-                    ipniPiece: true,
-                    ipniIpfs: false,
-                    storagePricePerTibPerMonth: 1 ether,
-                    minProvingPeriodInEpochs: 2880,
-                    location: "US-Central",
-                    paymentTokenAddress: IERC20(address(0)) // Payment in FIL
-                })
-            ),
-            new string[](0),
-            new string[](0)
+            keys,
+            values
         );
 
+        values[0] = bytes("https://sp3.com");
         vm.prank(sp3);
         serviceProviderRegistry.registerProvider{value: 5 ether}(
             sp3, // payee
             "SP3",
             "Storage Provider 3",
             ServiceProviderRegistryStorage.ProductType.PDP,
-            abi.encode(
-                ServiceProviderRegistryStorage.PDPOffering({
-                    serviceURL: "https://sp3.com",
-                    minPieceSizeInBytes: 1024,
-                    maxPieceSizeInBytes: 1024 * 1024,
-                    ipniPiece: true,
-                    ipniIpfs: false,
-                    storagePricePerTibPerMonth: 1 ether,
-                    minProvingPeriodInEpochs: 2880,
-                    location: "US-Central",
-                    paymentTokenAddress: IERC20(address(0)) // Payment in FIL
-                })
-            ),
-            new string[](0),
-            new string[](0)
+            keys,
+            values
         );
 
         // Deploy FilecoinPayV1 contract (no longer upgradeable)

service_contracts/test/FilecoinWarmStorageServiceOwner.t.sol

@@ -5,6 +5,7 @@ import {MockFVMTest} from "@fvm-solidity/mocks/MockFVMTest.sol";
 import {console} from "forge-std/Test.sol";
 import {FilecoinWarmStorageService} from "../src/FilecoinWarmStorageService.sol";
 import {FilecoinWarmStorageServiceStateView} from "../src/FilecoinWarmStorageServiceStateView.sol";
+import {PDPOffering} from "./PDPOffering.sol";
 import {ServiceProviderRegistry} from "../src/ServiceProviderRegistry.sol";
 import {ServiceProviderRegistryStorage} from "../src/ServiceProviderRegistryStorage.sol";
 import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
@@ -16,6 +17,7 @@ import {MockERC20, MockPDPVerifier} from "./mocks/SharedMocks.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 
 contract FilecoinWarmStorageServiceOwnerTest is MockFVMTest {
+    using PDPOffering for PDPOffering.Schema;
     using SafeERC20 for MockERC20;
 
     // Constants
@@ -131,28 +133,25 @@ contract FilecoinWarmStorageServiceOwnerTest is MockFVMTest {
     }
 
     function registerProvider(address provider, string memory name) internal {
-        string[] memory capabilityKeys = new string[](0);
-        string[] memory capabilityValues = new string[](0);
+        PDPOffering.Schema memory schema = PDPOffering.Schema({
+            serviceURL: "https://provider.com",
+            minPieceSizeInBytes: 1024,
+            maxPieceSizeInBytes: 1024 * 1024,
+            ipniPiece: false,
+            ipniIpfs: false,
+            storagePricePerTibPerDay: 25 * 10 ** 5, // 2.5 USDFC per TiB per month
+            minProvingPeriodInEpochs: 2880,
+            location: "US",
+            paymentTokenAddress: IERC20(address(0))
+        });
+        (string[] memory capabilityKeys, bytes[] memory capabilityValues) = schema.toCapabilities();
 
         vm.prank(provider);
         providerRegistry.registerProvider{value: 5 ether}(
             provider, // payee
             name,
             string.concat(name, " Description"),
             ServiceProviderRegistryStorage.ProductType.PDP,
-            abi.encode(
-                ServiceProviderRegistryStorage.PDPOffering({
-                    serviceURL: "https://provider.com",
-                    minPieceSizeInBytes: 1024,
-                    maxPieceSizeInBytes: 1024 * 1024,
-                    ipniPiece: false,
-                    ipniIpfs: false,
-                    storagePricePerTibPerMonth: 25 * 10 ** 5, // 2.5 USDFC per TiB per month
-                    minProvingPeriodInEpochs: 2880,
-                    location: "US",
-                    paymentTokenAddress: IERC20(address(0))
-                })
-            ),
             capabilityKeys,
             capabilityValues
         );