Merge branch 'feat/aggregation-mode-risc0' into feat/aggregation-mode-risc0-contracts

Author: MarcosNicolau

.github/workflows/build-and-test-rust.yml

@@ -31,6 +31,12 @@ jobs:
           source /home/runner/.bashrc
            ~/.sp1/bin/sp1up
 
+      - name: Install risc0 toolchain
+        run: |
+          curl -L https://risczero.com/install | bash
+          source /home/runner/.bashrc
+          /home/runner/.risc0/bin/rzup install
+
       - name: Cache Rust dependencies
         uses: actions/cache@v3
         with:
@@ -70,7 +76,8 @@ jobs:
       - name: Run Clippy on AggregationMode
         run: |
           cd aggregation_mode
-          cargo clippy --all -- -D warnings
+          # We need to skip the build as clippy does not support the riscv32im-risc0-zkvm-elf target
+          RISC0_SKIP_BUILD=1 cargo clippy --all -- -D warnings
 
   test:
     runs-on: aligned-runner
@@ -89,6 +96,12 @@ jobs:
           source /home/runner/.bashrc
            ~/.sp1/bin/sp1up
 
+      - name: Install risc0 toolchain
+        run: |
+          curl -L https://risczero.com/install | bash
+          source /home/runner/.bashrc
+          /home/runner/.risc0/bin/rzup install
+
       - name: Cache Rust dependencies
         uses: actions/cache@v3
         with:

Makefile

@@ -162,13 +162,13 @@ is_aggregator_set:
 		exit 1; \
 	fi
 
-start_proof_aggregator_local: is_aggregator_set ## Start the proof aggregator locally using Mock Verifier Contract
+start_proof_aggregator_dev: is_aggregator_set ## Starts proof aggregator with mock proofs (DEV mode)
 	RISC0_DEV_MODE=1 cargo run --manifest-path ./aggregation_mode/Cargo.toml --release --features $(AGGREGATOR) -- config-files/config-proof-aggregator-mock.yaml
 
-start_proof_aggregator_local_with_proving: is_aggregator_set ## Start the proof aggregator locally using SP1 Verifier Contract
+start_proof_aggregator: is_aggregator_set ## Starts proof aggregator with proving activated
 	cargo run --manifest-path ./aggregation_mode/Cargo.toml --release --features prove,$(AGGREGATOR) -- config-files/config-proof-aggregator.yaml
 
-start_proof_aggregator_local_with_proving_gpu: is_aggregator_set ## Start the proof aggregator locally using SP1 Verifier Contract
+start_proof_aggregator_gpu: is_aggregator_set ## Starts proof aggregator with proving + GPU acceleration (CUDA)
 	SP1_PROVER=cuda cargo run --manifest-path ./aggregation_mode/Cargo.toml --release --features prove,gpu,$(AGGREGATOR) -- config-files/config-proof-aggregator.yaml
 
 _AGGREGATOR_:
@@ -713,11 +713,11 @@ deploy_proof_aggregator:
 	@. contracts/scripts/.env.$(NETWORK) && . contracts/scripts/deploy_proof_aggregator.sh
 
 build_aligned_contracts:
-	@cd contracts/src/core && forge build
+	@cd contracts/src/core && forge build --via-ir
 
 show_aligned_error_codes:
 	@echo "\nAlignedLayerServiceManager errors:"
-	@cd contracts && forge inspect src/core/IAlignedLayerServiceManager.sol:IAlignedLayerServiceManager errors
+	@cd contracts && forge inspect src/core/IAligedLayerServiceManager.sol:IAlignedLayerServiceManager errors
 	@echo "\nBatcherPaymentService errors:"
 	@cd contracts && forge inspect src/core/BatcherPaymentService.sol:BatcherPaymentService errors
 

aggregation_mode/README.md

@@ -1,18 +1,19 @@
-
 # Aligned aggregation mode
 
 ## How to run it locally
 
 1. Deploy aligned contracts on anvil:
 
 ```shell
-make deploy_aligned_contracts
+make anvil_deploy_risc0_contracts
+make anvil_deploy_sp1_contracts
+make anvil_deploy_aligned_contracts
 ```
 
 2. Start anvil:
 
 ```shell
-make anvil_start_with_block_time
+make anvil_start
 ```
 
 3. Start batcher
@@ -21,26 +22,39 @@ make anvil_start_with_block_time
 make start_batcher_local
 ```
 
-4. Send SP1 proofs:
+4. Send SP1/Risc0 proofs:
 
 ```shell
 make batcher_send_sp1_burst
+make batcher_send_risc0_burst
 ```
 
+Notes:
+
+-   For SP1 only `compressed` proofs are supported
+-   For Risc0 both `succinct` and `composite` proofs are supported.
+
 5. Start proof aggregator:
 
 ```shell
 # This will not run a real prover but a mocked one see below to run a real prover
-make start_proof_aggregator_local
+make start_proof_aggregator_dev AGGREGATOR="sp1|risc0"
 ```
 
 or
 
 ```shell
-make start_proof_aggregator_local_with_proving
+make start_proof_aggregator AGGREGATOR="sp1|risc0"
 ```
 
-Note: Proving can be quite slow without GPUs
+Notes:
+
+-   Stark2Snark is only supported for x86 architecture in Risc0, so you won't be able to run the risc0 aggregator on Apple Silicon.
+-   Proving can be quite slow without GPUs, to activate gpu run:
+
+```shell
+make start_proof_aggregator_gpu AGGREGATOR="sp1|risc0"
+```
 
 ### Check the logs
 

aggregation_mode/src/aggregators/lib.rs

@@ -1,6 +1,6 @@
 use super::{
-    risc0_aggregator::{self, Risc0AggregationInput, Risc0ProofReceiptAndImageId},
-    sp1_aggregator::{self, SP1AggregationInput, SP1ProofWithPubValuesAndElf},
+    risc0_aggregator::{Risc0AggregationInput, Risc0ProofReceiptAndImageId},
+    sp1_aggregator::{SP1AggregationInput, SP1ProofWithPubValuesAndElf},
 };
 
 pub enum ProgramInput {
@@ -9,8 +9,8 @@ pub enum ProgramInput {
 }
 
 pub enum AggregatedProof {
-    SP1(SP1ProofWithPubValuesAndElf),
-    Risc0(Risc0ProofReceiptAndImageId),
+    SP1(Box<SP1ProofWithPubValuesAndElf>),
+    Risc0(Box<Risc0ProofReceiptAndImageId>),
 }
 
 pub struct ProgramOutput {
@@ -30,10 +30,3 @@ pub enum ProofAggregationError {
     Risc0Proving(String),
     UnsupportedProof,
 }
-
-pub fn aggregate_proofs(input: ProgramInput) -> Result<ProgramOutput, ProofAggregationError> {
-    match input {
-        ProgramInput::SP1(input) => sp1_aggregator::aggregate_proofs(input),
-        ProgramInput::Risc0(input) => risc0_aggregator::aggregate_proofs(input),
-    }
-}

aggregation_mode/src/aggregators/mod.rs

@@ -39,8 +39,8 @@ impl ZKVMEngine {
 }
 
 pub enum AlignedProof {
-    SP1(SP1ProofWithPubValuesAndElf),
-    Risc0(Risc0ProofReceiptAndImageId),
+    SP1(Box<SP1ProofWithPubValuesAndElf>),
+    Risc0(Box<Risc0ProofReceiptAndImageId>),
 }
 
 impl AlignedProof {

aggregation_mode/src/aggregators/risc0_aggregator.rs

@@ -33,7 +33,7 @@ impl Risc0ProofReceiptAndImageId {
 impl Risc0ProofReceiptAndImageId {
     pub fn hash_image_id_and_public_inputs(&self) -> [u8; 32] {
         let mut hasher = Keccak256::new();
-        hasher.update(&self.image_id);
+        hasher.update(self.image_id);
         hasher.update(self.public_inputs());
         hasher.finalize().into()
     }
@@ -88,7 +88,7 @@ pub(crate) fn aggregate_proofs(
         receipt,
     };
 
-    Ok(ProgramOutput::new(AggregatedProof::Risc0(output)))
+    Ok(ProgramOutput::new(AggregatedProof::Risc0(output.into())))
 }
 
 #[derive(Debug)]

aggregation_mode/src/aggregators/sp1_aggregator.rs

@@ -92,7 +92,7 @@ pub(crate) fn aggregate_proofs(
         elf: PROGRAM_ELF.to_vec(),
     };
 
-    let output = ProgramOutput::new(AggregatedProof::SP1(proof_and_elf));
+    let output = ProgramOutput::new(AggregatedProof::SP1(proof_and_elf.into()));
 
     Ok(output)
 }

aggregation_mode/src/backend/fetcher.rs

@@ -119,7 +119,7 @@ impl ProofsFetcher {
                                 elf,
                             };
 
-                            Some(AlignedProof::SP1(sp1_proof))
+                            Some(AlignedProof::SP1(sp1_proof.into()))
                         }
 
                         _ => None,
@@ -138,7 +138,7 @@ impl ProofsFetcher {
                             let receipt = Receipt::new(inner_receipt, public_inputs);
                             let risc0_proof = Risc0ProofReceiptAndImageId { image_id, receipt };
 
-                            Some(AlignedProof::Risc0(risc0_proof))
+                            Some(AlignedProof::Risc0(risc0_proof.into()))
                         }
                         _ => None,
                     })

aggregation_mode/src/backend/mod.rs

@@ -118,7 +118,7 @@ impl ProofAggregator {
                 let proofs = proofs
                     .into_iter()
                     .filter_map(|proof| match proof {
-                        AlignedProof::SP1(proof) => Some(proof),
+                        AlignedProof::SP1(proof) => Some(*proof),
                         _ => None,
                     })
                     .collect();
@@ -135,7 +135,7 @@ impl ProofAggregator {
                 let proofs = proofs
                     .into_iter()
                     .filter_map(|proof| match proof {
-                        AlignedProof::Risc0(proof) => Some(proof),
+                        AlignedProof::Risc0(proof) => Some(*proof),
                         _ => None,
                     })
                     .collect();