feat: turn program IDs into a mapping

Author: maximopalopoli

aggregation_mode/README.md

@@ -76,7 +76,9 @@ We are using docker to produce deterministic builds so that the program ids are
 
 ### Updating the program id in `AlignedProofAggregationService` contract
 
-If the program ids have changed, you will also need to update them in the `AlignedProofAggregationService` contract.
+If the program ids have changed, you will also need to add the updated one to the `AlignedProofAggregationService` contract. You can do this by calling the `addProgramId` method with the new image ID and the verifier type number as parameters (you can check the last parameter in the VerifierType definition at `contracts/src/core/AlignedProofAggregationService.sol`).
 
--   Risc0: call `setRisc0AggregatorProgramImageId` method with the value of `risc0_root_aggregator_image_id` from `aggregation_mode/program_ids.json`.
--   SP1: call: `setSP1AggregatorProgramVKHash` method with the value of `sp1_root_aggregator_vk_hash` from `aggregation_mode/program_ids.json`.
+You can fetch the program ID values from the following:
+
+- Risc0: Use the value of `risc0_root_aggregator_image_id` from `aggregation_mode/program_ids.json`.
+- SP1: Use the value of `sp1_root_aggregator_vk_hash` from `aggregation_mode/program_ids.json`.

aggregation_mode/abi/AlignedProofAggregationService.json

@@ -23,6 +23,8 @@ pub struct Config {
     pub ecdsa: ECDSAConfig,
     pub proofs_per_chunk: u16,
     pub total_proofs_limit: u16,
+    pub sp1_chunk_aggregator_vk_hash: String,
+    pub risc0_chunk_aggregator_image_id: String,
 }
 
 impl Config {

aggregation_mode/src/backend/config.rs

@@ -44,6 +44,8 @@ pub struct ProofAggregator {
     proof_aggregation_service: AlignedProofAggregationServiceContract,
     fetcher: ProofsFetcher,
     config: Config,
+    sp1_chunk_aggregator_vk_hash_bytes: [u8; 32],
+    risc0_chunk_aggregator_image_id_bytes: [u8; 32],
 }
 
 impl ProofAggregator {
@@ -66,11 +68,27 @@ impl ProofAggregator {
             ZKVMEngine::from_env().expect("AGGREGATOR env variable to be set to one of sp1|risc0");
         let fetcher = ProofsFetcher::new(&config);
 
+        let sp1_chunk_aggregator_vk_hash_bytes: [u8; 32] =
+            hex::decode(&config.sp1_chunk_aggregator_vk_hash)
+                .expect("Failed to decode SP1 chunk aggregator VK hash")
+                .as_slice()
+                .try_into()
+                .expect("SP1 chunk aggregator VK hash must be 32 bytes");
+
+        let risc0_chunk_aggregator_image_id_bytes: [u8; 32] =
+            hex::decode(&config.risc0_chunk_aggregator_image_id)
+                .expect("Failed to decode Risc0 chunk aggregator image id")
+                .as_slice()
+                .try_into()
+                .expect("Risc0 chunk aggregator image id must be 32 bytes");
+
         Self {
             engine,
             proof_aggregation_service,
             fetcher,
             config,
+            sp1_chunk_aggregator_vk_hash_bytes,
+            risc0_chunk_aggregator_image_id_bytes,
         }
     }
 
@@ -161,6 +179,7 @@ impl ProofAggregator {
                     blob_versioned_hash.into(),
                     proof.proof_with_pub_values.public_values.to_vec().into(),
                     proof.proof_with_pub_values.bytes().into(),
+                    self.sp1_chunk_aggregator_vk_hash_bytes.into(),
                 )
                 .sidecar(blob)
                 .into_transaction_request(),
@@ -173,6 +192,7 @@ impl ProofAggregator {
                         blob_versioned_hash.into(),
                         encoded_seal.into(),
                         proof.receipt.journal.bytes.into(),
+                        self.risc0_chunk_aggregator_image_id_bytes.into(),
                     )
                     .sidecar(blob)
                     .into_transaction_request()

aggregation_mode/src/backend/mod.rs

@@ -13,6 +13,11 @@ proofs_per_chunk: 512 # Amount of proofs to process per chunk
 # We can aggregate as much proofs as 126.976 / 32 = 3968 per blob
 total_proofs_limit: 3968
 
+# These program ids are the ones from the chunk aggregator programs
+# Can be found in the Proof Aggregation Service deployment config
+sp1_chunk_aggregator_vk_hash: "0x00a18429d092a8e1f58aea6ff650ad715ad4e6d7056600bb201d38460244507b"
+risc0_chunk_aggregator_image_id: "0x4cc11a4ac146ce4fc71493d694a9707194316cbb609603a195ffbe0c4c099c97"
+
 ecdsa:
   private_key_store_path: "config-files/anvil.proof-aggregator.ecdsa.key.json"
   private_key_store_password: ""

config-files/config-proof-aggregator-ethereum-package.yaml

@@ -13,6 +13,10 @@ proofs_per_chunk: 512 # Amount of proofs to process per chunk
 # We can aggregate as much proofs as 126.976 / 32 = 3968 per blob
 total_proofs_limit: 3968
 
+# These program ids are the ones from the chunk aggregator programs
+# Can be found in the Proof Aggregation Service deployment config
+sp1_chunk_aggregator_vk_hash: "0x00a18429d092a8e1f58aea6ff650ad715ad4e6d7056600bb201d38460244507b"
+risc0_chunk_aggregator_image_id: "0x4cc11a4ac146ce4fc71493d694a9707194316cbb609603a195ffbe0c4c099c97"
 
 ecdsa:
   private_key_store_path: "config-files/anvil.proof-aggregator.ecdsa.key.json"

config-files/config-proof-aggregator-mock-ethereum-package.yaml

@@ -13,6 +13,10 @@ proofs_per_chunk: 512 # Amount of proofs to process per chunk
 # We can aggregate as much proofs as 126.976 / 32 = 3968 per blob
 total_proofs_limit: 3968
 
+# These program ids are the ones from the chunk aggregator programs
+# Can be found in the Proof Aggregation Service deployment config
+sp1_chunk_aggregator_vk_hash: "0x00a18429d092a8e1f58aea6ff650ad715ad4e6d7056600bb201d38460244507b"
+risc0_chunk_aggregator_image_id: "0x4cc11a4ac146ce4fc71493d694a9707194316cbb609603a195ffbe0c4c099c97"
 
 ecdsa:
   private_key_store_path: "config-files/anvil.proof-aggregator.ecdsa.key.json"

config-files/config-proof-aggregator-mock.yaml

@@ -13,6 +13,10 @@ proofs_per_chunk: 512 # Amount of proofs to process per chunk
 # We can aggregate as much proofs as 126.976 / 32 = 3968 per blob
 total_proofs_limit: 3968
 
+# These program ids are the ones from the chunk aggregator programs
+# Can be found in the Proof Aggregation Service deployment config
+sp1_chunk_aggregator_vk_hash: "0x00a18429d092a8e1f58aea6ff650ad715ad4e6d7056600bb201d38460244507b"
+risc0_chunk_aggregator_image_id: "0x4cc11a4ac146ce4fc71493d694a9707194316cbb609603a195ffbe0c4c099c97"
 
 ecdsa:
   private_key_store_path: "config-files/anvil.proof-aggregator.ecdsa.key.json"

config-files/config-proof-aggregator.yaml

@@ -1,6 +1,7 @@
 pragma solidity ^0.8.12;
 
 import {AlignedProofAggregationService} from "../../src/core/AlignedProofAggregationService.sol";
+import {IAlignedProofAggregationService} from "../../src/core/IAlignedProofAggregationService.sol";
 import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
 
 import "forge-std/Script.sol";
@@ -24,16 +25,24 @@ contract AlignedProofAggregationServiceDeployer is Script {
 
         AlignedProofAggregationService alignedProofAggregationService = new AlignedProofAggregationService();
 
+        bytes32[] memory programIds = new bytes32[](2);
+        programIds[0] = risc0AggregationProgramImageId;
+        programIds[1] = sp1AggregationProgramVKHash;
+
+        uint8[] memory verifierTypes = new uint8[](2);
+        verifierTypes[0] = uint8(IAlignedProofAggregationService.VerifierType.RISC0);
+        verifierTypes[1] = uint8(IAlignedProofAggregationService.VerifierType.SP1);
+
         ERC1967Proxy proxy = new ERC1967Proxy(
             address(alignedProofAggregationService),
             abi.encodeWithSignature(
-                "initialize(address,address,address,address,bytes32,bytes32)",
+                "initialize(address,address,address,address,bytes32[],uint8[])",
                 ownerAddress,
                 alignedAggregatorAddress,
                 sp1VerifierAddress,
                 risc0VerifierAddress,
-                risc0AggregationProgramImageId,
-                sp1AggregationProgramVKHash
+                programIds,
+                verifierTypes
             )
         );
 

contracts/script/deploy/AlignedProofAggregationServiceDeployer.s.sol

@@ -37,13 +37,10 @@ contract AlignedProofAggregationService is
     /// if the sp1 verifier address is set to this address, then we skip verification
     address public constant VERIFIER_MOCK_ADDRESS = address(0xFF);
 
-    /// The unique identifier (image ID) of the RISC Zero aggregator program.
-    /// This ensures that only proofs generated by a trusted Risc0 program can be verified.
-    bytes32 public risc0AggregatorProgramImageId;
-
-    /// The verification key hash for the SP1 aggregator program.
-    /// This ensures that only proofs generated by a trusted SP1 program can be verified.
-    bytes32 public sp1AggregatorProgramVKHash;
+    /// @notice A mapping to track valid program IDs (image IDs for RISC Zero or vk hashes for SP1)
+    /// to their corresponding verifier types. These program IDs are used to ensure that proofs are
+    /// verified against known and registered programs.
+    mapping(bytes32 => uint8) public programIds;
 
     constructor() {
         _disableInitializers();
@@ -54,45 +51,54 @@ contract AlignedProofAggregationService is
         address _alignedAggregatorAddress,
         address _sp1VerifierAddress,
         address _risc0VerifierAddress,
-        bytes32 _risc0AggregatorProgramImageId,
-        bytes32 _sp1AggregatorProgramVKHash
+        bytes32[] memory _programIds,
+        uint8[] memory _verifierTypes
     ) public initializer {
         __Ownable_init();
         __UUPSUpgradeable_init();
         _transferOwnership(newOwner);
         alignedAggregatorAddress = _alignedAggregatorAddress;
         sp1VerifierAddress = _sp1VerifierAddress;
         risc0VerifierAddress = _risc0VerifierAddress;
-        risc0AggregatorProgramImageId = _risc0AggregatorProgramImageId;
-        sp1AggregatorProgramVKHash = _sp1AggregatorProgramVKHash;
+        for (uint256 i = 0; i < _programIds.length; i++) {
+            programIds[_programIds[i]] = _verifierTypes[i];
+        }
     }
 
-    function verifySP1(bytes32 blobVersionedHash, bytes calldata sp1PublicValues, bytes calldata sp1ProofBytes)
+    function verifySP1(bytes32 blobVersionedHash, bytes calldata sp1PublicValues, bytes calldata sp1ProofBytes, bytes32 programId)
         public
         onlyAlignedAggregator
     {
         (bytes32 merkleRoot) = abi.decode(sp1PublicValues, (bytes32));
 
+        if (programIds[programId] != uint8(IAlignedProofAggregationService.VerifierType.SP1)) {
+            revert InvalidProgramId(programId, IAlignedProofAggregationService.VerifierType.SP1, programIds[programId]);
+        }
+
         // In dev mode, poofs are mocked, so we skip the verification part
         if (_isSP1VerificationEnabled()) {
-            ISP1Verifier(sp1VerifierAddress).verifyProof(sp1AggregatorProgramVKHash, sp1PublicValues, sp1ProofBytes);
+            ISP1Verifier(sp1VerifierAddress).verifyProof(programId, sp1PublicValues, sp1ProofBytes);
         }
 
         aggregatedProofs[merkleRoot] = true;
         emit AggregatedProofVerified(merkleRoot, blobVersionedHash);
     }
 
-    function verifyRisc0(bytes32 blobVersionedHash, bytes calldata risc0ReceiptSeal, bytes calldata risc0JournalBytes)
+    function verifyRisc0(bytes32 blobVersionedHash, bytes calldata risc0ReceiptSeal, bytes calldata risc0JournalBytes, bytes32 programId)
         public
         onlyAlignedAggregator
     {
         (bytes32 merkleRoot) = abi.decode(risc0JournalBytes, (bytes32));
 
+        if (programIds[programId] != uint8(IAlignedProofAggregationService.VerifierType.RISC0)) {
+            revert InvalidProgramId(programId, IAlignedProofAggregationService.VerifierType.RISC0, programIds[programId]);
+        }
+
         // In dev mode, poofs are mocked, so we skip the verification part
         if (_isRisc0VerificationEnabled()) {
             bytes32 risc0JournalDigest = sha256(risc0JournalBytes);
             IRiscZeroVerifier(risc0VerifierAddress).verify(
-                risc0ReceiptSeal, risc0AggregatorProgramImageId, risc0JournalDigest
+                risc0ReceiptSeal, programId, risc0JournalDigest
             );
         }
 
@@ -153,24 +159,26 @@ contract AlignedProofAggregationService is
         emit Risc0VerifierAddressUpdated(_risc0VerifierAddress);
     }
 
-    /// @notice Sets the image id of the Risc0 program
-    /// @param _risc0AggregatorProgramImageId The new imageid for the Risc0 aggregator program
-    function setRisc0AggregatorProgramImageId(bytes32 _risc0AggregatorProgramImageId) external onlyOwner {
-        risc0AggregatorProgramImageId = _risc0AggregatorProgramImageId;
-        emit Risc0AggregatorProgramImageIdUpdated(_risc0AggregatorProgramImageId);
-    }
-
     /// @notice Sets the address of the SP1 verifier contract
     /// @param _sp1VerifierAddress The new address for the SP1 verifier contract
     function setSP1VerifierAddress(address _sp1VerifierAddress) external onlyOwner {
         sp1VerifierAddress = _sp1VerifierAddress;
         emit SP1VerifierAddressUpdated(_sp1VerifierAddress);
     }
 
-    /// @notice Sets the vk hash of the sp1 program
-    /// @param _sp1AggregatorProgramVKHash The new vk hash for the sp1 aggregator program
-    function setSP1AggregatorProgramVKHash(bytes32 _sp1AggregatorProgramVKHash) external onlyOwner {
-        sp1AggregatorProgramVKHash = _sp1AggregatorProgramVKHash;
-        emit SP1AggregatorProgramVKHashUpdated(_sp1AggregatorProgramVKHash);
+    /// @notice Adds a new program ID to the list of valid program IDs.
+    /// @param programId The program ID to add (image ID for RISC0 or vk hash for SP1).
+    /// @param verifierType The type of verifier associated with the program ID.
+    function addProgramId(bytes32 programId, IAlignedProofAggregationService.VerifierType verifierType) external onlyOwner {
+        programIds[programId] = uint8(verifierType);
+        emit ProgramIdAdded(programId, verifierType);
+    }
+
+    /// @notice Deletes a program ID from the list of valid program IDs.
+    /// @param programId The program ID to delete (image ID for RISC0 or vk hash for SP1).
+    function deleteProgramId(bytes32 programId) external onlyOwner {
+        // Check if we should verify its existence before deleting
+        delete programIds[programId];
+        emit ProgramIdDeleted(programId);
     }
 }