feat(l2): add prover benchmarking tooling and documentation

cmd/ethrex/l2/deployer.rs

@@ -1015,17 +1015,17 @@ fn get_vk(prover_type: ProverType, opts: &DeployerOptions) -> Result<Bytes, Depl
         let vk_path = {
             let path = match &prover_type {
                 ProverType::RISC0 => format!(
-                    "{}/../../crates/l2/prover/src/ethrex_guest_program/src/risc0/out/riscv32im-risc0-vk",
+                    "{}/../../crates/guest-program/bin/risc0/out/riscv32im-risc0-vk",
                     env!("CARGO_MANIFEST_DIR")
                 ),
                 // Aligned requires the vk's 32 bytes hash, while the L1 verifier requires
                 // the hash as a bn254 F_r element.
                 ProverType::SP1 if opts.aligned => format!(
-                    "{}/../../crates/l2/prover/src/ethrex_guest_program/src/sp1/out/riscv32im-succinct-zkvm-vk-u32",
+                    "{}/../../crates/guest-program/bin/sp1/out/riscv32im-succinct-zkvm-vk-u32",
                     env!("CARGO_MANIFEST_DIR")
                 ),
                 ProverType::SP1 if !opts.aligned => format!(
-                    "{}/../../crates/l2/prover/src/ethrex_guest_program/src/sp1/out/riscv32im-succinct-zkvm-vk-bn254",
+                    "{}/../../crates/guest-program/bin/sp1/out/riscv32im-succinct-zkvm-vk-bn254",
                     env!("CARGO_MANIFEST_DIR")
                 ),
                 // other types don't have a verification key

cmd/ethrex/l2/options.rs

@@ -1081,6 +1081,14 @@ pub struct ProverClientOptions {
         help_heading = "Prover client options"
     )]
     pub log_level: Level,
+    #[arg(
+        long,
+        default_value_t = false,
+        env = "PROVER_CLIENT_TIMED",
+        help = "Measure and log proving time for each batch",
+        help_heading = "Prover client options"
+    )]
+    pub timed: bool,
     #[cfg(all(feature = "sp1", feature = "gpu"))]
     #[arg(
         long,
@@ -1098,6 +1106,7 @@ impl From<ProverClientOptions> for ProverConfig {
             backend: config.backend,
             proof_coordinators: config.proof_coordinator_endpoints,
             proving_time_ms: config.proving_time_ms,
+            timed: config.timed,
             #[cfg(all(feature = "sp1", feature = "gpu"))]
             sp1_server: config.sp1_server,
         }
@@ -1113,6 +1122,7 @@ impl Default for ProverClientOptions {
             proving_time_ms: 5000,
             log_level: Level::INFO,
             backend: BackendType::Exec,
+            timed: false,
             #[cfg(all(feature = "sp1", feature = "gpu"))]
             sp1_server: None,
         }

crates/l2/Makefile

@@ -100,15 +100,12 @@ deploy-l1: ## 📜 Deploys the L1 contracts
 	--genesis-l2-path ${L2_GENESIS_FILE_PATH}
 
 ## Same as deploy-l1 but deploys the SP1 verifier
-deploy-l1-sp1: ## 📜 Deploys the L1 contracts
+deploy-l1-sp1: ## 📜 Deploys the L1 contracts with SP1 verifier
 	COMPILE_CONTRACTS=true \
 	cargo run --release --features l2,l2-sql --manifest-path ../../Cargo.toml -- l2 deploy \
 	--eth-rpc-url ${L1_RPC_URL} \
 	--private-key ${L1_PRIVATE_KEY} \
-	--risc0.verifier-address 0x00000000000000000000000000000000000000aa \
-	--sp1.deploy-verifier \
-	--tdx.verifier-address 0x00000000000000000000000000000000000000aa \
-	--aligned.aggregator-address 0x00000000000000000000000000000000000000aa \
+	--sp1 true \
 	--on-chain-proposer-owner ${L2_OWNER_ADDRESS} \
 	--bridge-owner ${L2_OWNER_ADDRESS} \
 	--bridge-owner-pk ${BRIDGE_OWNER_PRIVATE_KEY} \

crates/l2/common/src/prover.rs

@@ -179,13 +179,24 @@ pub enum ProofData {
     /// The Client initiates the connection with a BatchRequest.
     /// Asking for the ProverInputData the prover_server considers/needs.
     /// The commit hash is used to ensure the client and server are compatible.
-    BatchRequest { commit_hash: String },
+    /// The prover_type tells the coordinator which backend the client runs,
+    /// so it can skip batches that already have a proof for that type.
+    BatchRequest {
+        commit_hash: String,
+        prover_type: ProverType,
+    },
 
     /// 4.
-    /// The Server responds with a NoBatchForVersion if the code version is not the same as the one
-    /// generated in the batch.
-    /// The Client can only prove batches of its own version.
-    NoBatchForVersion { commit_hash: String },
+    /// The Server responds with VersionMismatch when the prover's code version
+    /// does not match the version needed to prove the next batch. This can happen
+    /// when the batch was stored with a different version, or when the prover is
+    /// stale and future batches will use a newer version.
+    VersionMismatch,
+
+    /// 4b.
+    /// The Server responds with ProverTypeNotNeeded when the connecting prover's
+    /// backend type is not in the set of required proof types for this deployment.
+    ProverTypeNotNeeded { prover_type: ProverType },
 
     /// 5.
     /// The Server responds with a BatchResponse containing the ProverInputData.
@@ -224,13 +235,16 @@ impl ProofData {
     }
 
     /// Builder function for creating a BatchRequest
-    pub fn batch_request(commit_hash: String) -> Self {
-        ProofData::BatchRequest { commit_hash }
+    pub fn batch_request(commit_hash: String, prover_type: ProverType) -> Self {
+        ProofData::BatchRequest {
+            commit_hash,
+            prover_type,
+        }
     }
 
-    /// Builder function for creating a NoBatchForVersion
-    pub fn no_batch_for_version(commit_hash: String) -> Self {
-        ProofData::NoBatchForVersion { commit_hash }
+    /// Builder function for creating a VersionMismatch
+    pub fn version_mismatch() -> Self {
+        ProofData::VersionMismatch
     }
 
     /// Builder function for creating a BatchResponse

crates/l2/prover/src/backend/exec.rs

@@ -39,6 +39,10 @@ impl ProverBackend for ExecBackend {
     type ProofOutput = ProgramOutput;
     type SerializedInput = ();
 
+    fn prover_type(&self) -> ProverType {
+        ProverType::Exec
+    }
+
     fn serialize_input(
         &self,
         _input: &ProgramInput,

crates/l2/prover/src/backend/mod.rs

@@ -3,7 +3,7 @@ use std::time::{Duration, Instant};
 
 use clap::ValueEnum;
 use ethrex_guest_program::input::ProgramInput;
-use ethrex_l2_common::prover::{BatchProof, ProofFormat};
+use ethrex_l2_common::prover::{BatchProof, ProofFormat, ProverType};
 use serde::{Deserialize, Serialize};
 
 pub mod error;
@@ -85,6 +85,9 @@ pub trait ProverBackend {
     /// The serialized input type specific to this backend.
     type SerializedInput;
 
+    /// Returns the ProverType for this backend.
+    fn prover_type(&self) -> ProverType;
+
     /// Serialize the program input into the backend-specific format.
     fn serialize_input(&self, input: &ProgramInput) -> Result<Self::SerializedInput, BackendError>;
 

crates/l2/prover/src/backend/openvm.rs

@@ -1,7 +1,7 @@
 use std::time::{Duration, Instant};
 
 use ethrex_guest_program::input::ProgramInput;
-use ethrex_l2_common::prover::{BatchProof, ProofFormat};
+use ethrex_l2_common::prover::{BatchProof, ProofFormat, ProverType};
 use openvm_continuations::verifier::internal::types::VmStarkProof;
 use openvm_sdk::{Sdk, StdIn, types::EvmProof};
 use openvm_stark_sdk::config::baby_bear_poseidon2::BabyBearPoseidon2Config;
@@ -64,6 +64,10 @@ impl ProverBackend for OpenVmBackend {
     type ProofOutput = OpenVmProveOutput;
     type SerializedInput = StdIn;
 
+    fn prover_type(&self) -> ProverType {
+        unimplemented!("OpenVM is not yet enabled as a backend for the L2")
+    }
+
     fn serialize_input(&self, input: &ProgramInput) -> Result<Self::SerializedInput, BackendError> {
         let mut stdin = StdIn::default();
         let bytes = rkyv::to_bytes::<Error>(input).map_err(BackendError::serialization)?;

crates/l2/prover/src/backend/risc0.rs

@@ -89,6 +89,10 @@ impl ProverBackend for Risc0Backend {
     type ProofOutput = Receipt;
     type SerializedInput = ExecutorEnv<'static>;
 
+    fn prover_type(&self) -> ProverType {
+        ProverType::RISC0
+    }
+
     fn serialize_input(&self, input: &ProgramInput) -> Result<Self::SerializedInput, BackendError> {
         let bytes = rkyv::to_bytes::<RkyvError>(input).map_err(BackendError::serialization)?;
         ExecutorEnv::builder()

crates/l2/prover/src/backend/sp1.rs

@@ -143,6 +143,10 @@ impl ProverBackend for Sp1Backend {
     type ProofOutput = Sp1ProveOutput;
     type SerializedInput = SP1Stdin;
 
+    fn prover_type(&self) -> ProverType {
+        ProverType::SP1
+    }
+
     fn serialize_input(&self, input: &ProgramInput) -> Result<Self::SerializedInput, BackendError> {
         let mut stdin = SP1Stdin::new();
         let bytes = rkyv::to_bytes::<Error>(input).map_err(BackendError::serialization)?;

crates/l2/prover/src/backend/zisk.rs

@@ -5,7 +5,7 @@ use std::{
 };
 
 use ethrex_guest_program::{ZKVM_ZISK_PROGRAM_ELF, input::ProgramInput};
-use ethrex_l2_common::prover::{BatchProof, ProofFormat};
+use ethrex_l2_common::prover::{BatchProof, ProofFormat, ProverType};
 
 use crate::backend::{BackendError, ProverBackend};
 
@@ -113,6 +113,10 @@ impl ProverBackend for ZiskBackend {
     type ProofOutput = ZiskProveOutput;
     type SerializedInput = ();
 
+    fn prover_type(&self) -> ProverType {
+        unimplemented!("ZisK is not yet enabled as a backend for the L2")
+    }
+
     fn serialize_input(&self, input: &ProgramInput) -> Result<Self::SerializedInput, BackendError> {
         let input_bytes =
             rkyv::to_bytes::<rkyv::rancor::Error>(input).map_err(BackendError::serialization)?;

crates/l2/prover/src/config.rs

@@ -8,6 +8,7 @@ pub struct ProverConfig {
     pub backend: BackendType,
     pub proof_coordinators: Vec<Url>,
     pub proving_time_ms: u64,
+    pub timed: bool,
     #[cfg(all(feature = "sp1", feature = "gpu"))]
     pub sp1_server: Option<Url>,
 }

crates/l2/prover/src/prover.rs

@@ -4,7 +4,7 @@ use crate::{
 };
 use ethrex_guest_program::input::ProgramInput;
 use ethrex_l2::sequencer::utils::get_git_commit_hash;
-use ethrex_l2_common::prover::{BatchProof, ProofData, ProofFormat};
+use ethrex_l2_common::prover::{BatchProof, ProofData, ProofFormat, ProverType};
 use std::time::Duration;
 use tokio::{
     io::{AsyncReadExt, AsyncWriteExt},
@@ -57,10 +57,23 @@ struct ProverData {
     format: ProofFormat,
 }
 
+/// The result of polling a proof coordinator for work.
+enum InputRequest {
+    /// A batch was assigned to this prover.
+    Batch(Box<ProverData>),
+    /// No work available right now (prover ahead of proposer, proof already
+    /// exists, version mismatch). The prover should retry later.
+    RetryLater,
+    /// The coordinator permanently rejected this prover's type.
+    /// The prover should skip this coordinator and continue with others.
+    ProverTypeNotNeeded(ProverType),
+}
+
 struct Prover<B: ProverBackend> {
     backend: B,
     proof_coordinator_endpoints: Vec<Url>,
     proving_time_ms: u64,
+    timed: bool,
     commit_hash: String,
 }
 
@@ -70,6 +83,7 @@ impl<B: ProverBackend> Prover<B> {
             backend,
             proof_coordinator_endpoints: cfg.proof_coordinators.clone(),
             proving_time_ms: cfg.proving_time_ms,
+            timed: cfg.timed,
             commit_hash: get_git_commit_hash(),
         }
     }
@@ -82,27 +96,55 @@ impl<B: ProverBackend> Prover<B> {
                 .map(|url| url.to_string())
                 .collect::<Vec<String>>()
         );
-        // Build the prover depending on the prover_type passed as argument.
         loop {
             sleep(Duration::from_millis(self.proving_time_ms)).await;
 
             for endpoint in &self.proof_coordinator_endpoints {
-                let Ok(Some(prover_data)) = self
-                    .request_new_input(endpoint)
-                    .await
-                    .inspect_err(|e| error!(%endpoint, "Failed to request new data from: {e}"))
-                else {
-                    continue;
+                let prover_data = match self.request_new_input(endpoint).await {
+                    Ok(InputRequest::Batch(data)) => *data,
+                    Ok(InputRequest::RetryLater) => continue,
+                    Ok(InputRequest::ProverTypeNotNeeded(prover_type)) => {
+                        error!(
+                            %endpoint,
+                            "Proof coordinator does not need {prover_type} proofs. \
+                             This prover's backend is not in the required proof types \
+                             for this deployment."
+                        );
+                        continue;
+                    }
+                    Err(e) => {
+                        error!(%endpoint, "Failed to request new data: {e}");
+                        continue;
+                    }
                 };
 
-                // If we get the input
-                // Generate the Proof
-                let Ok(batch_proof) = self
-                    .backend
-                    .prove(prover_data.input, prover_data.format)
-                    .and_then(|output| self.backend.to_batch_proof(output, prover_data.format))
-                    .inspect_err(|e| error!("{e}"))
-                else {
+                let batch_proof = if self.timed {
+                    self.backend
+                        .prove_timed(prover_data.input, prover_data.format)
+                        .and_then(|(output, elapsed)| {
+                            info!(
+                                batch = prover_data.batch_number,
+                                proving_time_s = elapsed.as_secs(),
+                                proving_time_ms =
+                                    u64::try_from(elapsed.as_millis()).unwrap_or(u64::MAX),
+                                "Proved batch {} in {:.2?}",
+                                prover_data.batch_number,
+                                elapsed
+                            );
+                            self.backend.to_batch_proof(output, prover_data.format)
+                        })
+                } else {
+                    self.backend
+                        .prove(prover_data.input, prover_data.format)
+                        .and_then(|output| {
+                            info!(
+                                batch = prover_data.batch_number,
+                                "Proved batch {}", prover_data.batch_number
+                            );
+                            self.backend.to_batch_proof(output, prover_data.format)
+                        })
+                };
+                let Ok(batch_proof) = batch_proof.inspect_err(|e| error!("{e}")) else {
                     continue;
                 };
 
@@ -116,9 +158,9 @@ impl<B: ProverBackend> Prover<B> {
         }
     }
 
-    async fn request_new_input(&self, endpoint: &Url) -> Result<Option<ProverData>, String> {
-        // Request the input with the correct batch_number
-        let request = ProofData::batch_request(self.commit_hash.clone());
+    async fn request_new_input(&self, endpoint: &Url) -> Result<InputRequest, String> {
+        let request =
+            ProofData::batch_request(self.commit_hash.clone(), self.backend.prover_type());
         let response = connect_to_prover_server_wr(endpoint, &request)
             .await
             .map_err(|e| format!("Failed to get Response: {e}"))?;
@@ -129,22 +171,25 @@ impl<B: ProverBackend> Prover<B> {
                 input,
                 format,
             } => (batch_number, input, format),
-            ProofData::NoBatchForVersion { commit_hash } => {
+            ProofData::VersionMismatch => {
                 warn!(
-                    "Received no batch available to prove for current version: {}. The prover may be older or newer to the next batch to prove",
-                    commit_hash,
+                    "Version mismatch: the next batch to prove was built with a different code \
+                     version. This prover may need to be updated."
                 );
-                return Ok(None);
+                return Ok(InputRequest::RetryLater);
+            }
+            ProofData::ProverTypeNotNeeded { prover_type } => {
+                return Ok(InputRequest::ProverTypeNotNeeded(prover_type));
             }
             _ => return Err("Expecting ProofData::Response".to_owned()),
         };
 
         let (Some(batch_number), Some(input), Some(format)) = (batch_number, input, format) else {
-            warn!(
+            debug!(
                 %endpoint,
-                "Received Empty Response, meaning that the ProverServer doesn't have batches to prove.\nThe Prover may be advancing faster than the Proposer."
+                "No batches to prove right now, the prover may be ahead of the proposer"
             );
-            return Ok(None);
+            return Ok(InputRequest::RetryLater);
         };
 
         info!(%endpoint, "Received Response for batch_number: {batch_number}");
@@ -162,11 +207,11 @@ impl<B: ProverBackend> Prover<B> {
             blocks: input.blocks,
             execution_witness: input.execution_witness,
         };
-        Ok(Some(ProverData {
+        Ok(InputRequest::Batch(Box::new(ProverData {
             batch_number,
             input,
             format,
-        }))
+        })))
     }
 
     async fn submit_proof(