feat(aggregation-mode): turn program IDs into a mapping

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_chunk_aggregator_image_id` from `aggregation_mode/program_ids.json`.
+- SP1: Use the value of `sp1_chunk_aggregator_vk_hash` from `aggregation_mode/program_ids.json`.

aggregation_mode/src/backend/config.rs

@@ -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/mod.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,25 @@ 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")
+                .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")
+                .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 +177,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 +190,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()

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

@@ -13,6 +13,12 @@ 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
+# (remember to trim the 0x prefix)
+sp1_chunk_aggregator_vk_hash: "00ba19eed0aaeb0151f07b8d3ee7c659bcd29f3021e48fb42766882f55b84509"
+risc0_chunk_aggregator_image_id: "d8cfdd5410c70395c0a1af1842a0148428cc46e353355faccfba694dd4862dbf"
+
 ecdsa:
   private_key_store_path: "config-files/anvil.proof-aggregator.ecdsa.key.json"
   private_key_store_password: ""

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

@@ -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
+# (remember to trim the 0x prefix)
+sp1_chunk_aggregator_vk_hash: "00ba19eed0aaeb0151f07b8d3ee7c659bcd29f3021e48fb42766882f55b84509"
+risc0_chunk_aggregator_image_id: "d8cfdd5410c70395c0a1af1842a0148428cc46e353355faccfba694dd4862dbf"
 
 ecdsa:
   private_key_store_path: "config-files/anvil.proof-aggregator.ecdsa.key.json"

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

@@ -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
+# (remember to trim the 0x prefix)
+sp1_chunk_aggregator_vk_hash: "00ba19eed0aaeb0151f07b8d3ee7c659bcd29f3021e48fb42766882f55b84509"
+risc0_chunk_aggregator_image_id: "d8cfdd5410c70395c0a1af1842a0148428cc46e353355faccfba694dd4862dbf"
 
 ecdsa:
   private_key_store_path: "config-files/anvil.proof-aggregator.ecdsa.key.json"

config-files/config-proof-aggregator.yaml

@@ -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
+# (remember to trim the 0x prefix)
+sp1_chunk_aggregator_vk_hash: "00ba19eed0aaeb0151f07b8d3ee7c659bcd29f3021e48fb42766882f55b84509"
+risc0_chunk_aggregator_image_id: "d8cfdd5410c70395c0a1af1842a0148428cc46e353355faccfba694dd4862dbf"
 
 ecdsa:
   private_key_store_path: "config-files/anvil.proof-aggregator.ecdsa.key.json"

contracts/script/deploy/AlignedProofAggregationServiceDeployer.s.sol

@@ -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/src/core/AlignedProofAggregationService.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 map to track aggregation program IDs (image IDs for RISC Zero or vk hashes for SP1)
+    /// with their proving system. These program IDs are used to validate that the proofs to verify are indeed from
+    /// a trusted aggregation program.
+    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, proofs 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, proofs are mocked, so we skip the verification part
         if (_isRisc0VerificationEnabled()) {
             bytes32 risc0JournalDigest = sha256(risc0JournalBytes);
             IRiscZeroVerifier(risc0VerifierAddress).verify(
-                risc0ReceiptSeal, risc0AggregatorProgramImageId, risc0JournalDigest
+                risc0ReceiptSeal, programId, risc0JournalDigest
             );
         }
 
@@ -148,31 +154,55 @@ contract AlignedProofAggregationService is
         _;
     }
 
+    /// @notice Modifier to ensure the provided verifier type is one of the valid enum values.
+    modifier onValidVerifierType(IAlignedProofAggregationService.VerifierType verifierType) {
+        if (verifierType != IAlignedProofAggregationService.VerifierType.SP1 &&
+            verifierType != IAlignedProofAggregationService.VerifierType.RISC0){
+                revert IAlignedProofAggregationService.InvalidVerifierType(uint8(verifierType));
+            }
+
+        _;
+    }
+
     /// @notice Sets the address of the Risc0 verifier contract
     /// @param _risc0VerifierAddress The new address for the Risc0 verifier contract
     function setRisc0VerifierAddress(address _risc0VerifierAddress) external onlyOwner {
         risc0VerifierAddress = _risc0VerifierAddress;
         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
+        onValidVerifierType(verifierType)
+    {
+        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, IAlignedProofAggregationService.VerifierType verifierType) external onlyOwner onValidVerifierType(verifierType) {
+        // Preserve the verifier type so we can emit it with the event
+        uint8 verifierTypeRaw = programIds[programId];
+        uint8 rawReceivedVerifierType = uint8(verifierType);
+
+        // Check if the obtained verifier type matches the one received by param
+        if (verifierTypeRaw != rawReceivedVerifierType) {
+            revert IAlignedProofAggregationService.VerifierTypeMismatch(verifierTypeRaw, rawReceivedVerifierType);
+        }
+
+        delete programIds[programId];
+        emit ProgramIdDeleted(programId, IAlignedProofAggregationService.VerifierType(verifierTypeRaw));
     }
 }

contracts/src/core/IAlignedProofAggregationService.sol

@@ -9,23 +9,24 @@ interface IAlignedProofAggregationService {
 
     /// @notice Event emitted when the SP1 verifier address is updated
     event SP1VerifierAddressUpdated(address indexed newAddress);
+
+    /// @notice Event emitted when a new program ID is added
+    event ProgramIdAdded(bytes32 indexed programId, VerifierType verifierType);
 
-    /// @notice Event emitted when the Risc0 aggregator program image ID is updated
-    event Risc0AggregatorProgramImageIdUpdated(bytes32 indexed newImageId);
-
-    /// @notice Event emitted when the SP1 aggregator program VK hash is updated
-    event SP1AggregatorProgramVKHashUpdated(bytes32 indexed newVKHash);
+    /// @notice Event emitted when a program ID is deleted
+    event ProgramIdDeleted(bytes32 indexed programId, VerifierType verifierType);
 
     /// @notice Method to verify an aggregated proof from aligned
     /// @dev This function is called by the aligned proof aggregator after collecting the proofs and aggregating them
     /// to be verified on-chain. We expect the blobTransactionHash to be called before
     /// @param blobVersionedHash the versioned hash of the blob transaction that contains the leaves that compose the merkle root.
     /// @param sp1PublicValues Values used to perform the execution
     /// @param sp1ProofBytes Groth16 proof
-    function verifySP1(bytes32 blobVersionedHash, bytes calldata sp1PublicValues, bytes calldata sp1ProofBytes)
+    /// @param programId The chunk aggregator program ID against which the proof should be verified
+    function verifySP1(bytes32 blobVersionedHash, bytes calldata sp1PublicValues, bytes calldata sp1ProofBytes, bytes32 programId)
         external;
 
-    function verifyRisc0(bytes32 blobVersionedHash, bytes calldata risc0ReceiptSeal, bytes calldata risc0JournalBytes)
+    function verifyRisc0(bytes32 blobVersionedHash, bytes calldata risc0ReceiptSeal, bytes calldata risc0JournalBytes, bytes32 programId)
         external;
 
     function verifyProofInclusion(
@@ -39,17 +40,31 @@ interface IAlignedProofAggregationService {
     /// @param _risc0VerifierAddress The new address for the Risc0 verifier contract
     function setRisc0VerifierAddress(address _risc0VerifierAddress) external;
 
-    /// @notice Sets the image id of the Risc0 program
-    /// @param _risc0AggregatorProgramImageId The new imageid for the Risc0 aggregator program
-    function setRisc0AggregatorProgramImageId(bytes32 _risc0AggregatorProgramImageId) external;
-
     /// @notice Sets the address of the SP1 verifier contract
     /// @param _sp1VerifierAddress The new address for the SP1 verifier contract
     function setSP1VerifierAddress(address _sp1VerifierAddress) external;
 
-    /// @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;
+    /// @notice Adds a new program ID with its verifier type
+    /// @param programId The program ID to add
+    /// @param verifierType The type of verifier (SP1 or RISC0)
+    function addProgramId(bytes32 programId, VerifierType verifierType) external;
+
+    /// @notice Deletes an existing program ID
+    /// @param programId The program ID to delete
+    /// @param verifierType The type of verifier (SP1 or RISC0)
+    function deleteProgramId(bytes32 programId, VerifierType verifierType) external;
 
     error OnlyAlignedAggregator(address sender);
+
+    error InvalidProgramId(bytes32 programId, VerifierType expected, uint8 actual);
+
+    error InvalidVerifierType(uint8 actual);
+
+    error VerifierTypeMismatch(uint8 expected, uint8 received);
+
+    enum VerifierType {
+        INVALID,  // If a given program does not exist in the `programId` map, it defaults to 0. This prevents non-existing keys to be considered valid in case SP1 or RISC0 were in this position
+        SP1,
+        RISC0
+    }
 }

explorer/lib/explorer/contract_managers/aligned_proof_aggregation_service.ex

@@ -2,8 +2,8 @@ defmodule AlignedProofAggregationService do
   require Logger
 
   @aligned_config_file System.get_env("ALIGNED_PROOF_AGG_CONFIG_FILE")
-  @verifyRisc0_solidity_signature "0x54687ccf"
-  @verifySp1_solidity_signature "0xf6e04ac4"
+  @verifyRisc0_solidity_signature "0x0769eb53"
+  @verifySp1_solidity_signature "0x96f7966f"
 
   config_file_path =
     case @aligned_config_file do

infra/aggregation_mode/config-proof-aggregator-risc0.template.yaml

@@ -12,6 +12,8 @@ proofs_per_chunk: 512 # Amount of proofs to process per chunk
 # Since each proof commitments takes 32 bytes hash
 # We can aggregate as much proofs as 126.976 / 32 = 3968 per blob
 total_proofs_limit: 3968
+sp1_chunk_aggregator_vk_hash: 00a18429d092a8e1f58aea6ff650ad715ad4e6d7056600bb201d38460244507b
+risc0_chunk_aggregator_image_id: 4cc11a4ac146ce4fc71493d694a9707194316cbb609603a195ffbe0c4c099c97
 
 ecdsa:
     private_key_store_path: <private_key_store_path>