feat(l2): exchange commit hash in node-prover communication (#3339)

**Motivation**

We want to prevent a divergence between the code that is running in the
L2 node and the prover.

**Description**

- Updates the client version to use `GIT_BRANCH` and `GIT_SHA` instead
of `RUSTC_COMMIT_HASH`.
- Adds a `build.rs` script for both the node and prover, using
`vergen_git2` to export the git env vars.
- Adds a `code_version` field to the `BatchRequest` message.
- Introduces a new `ProofData` message: `InvalidCodeVersion`.

## How to test

You can create an empty commit with:

```bash
git commit --allow-empty -m "empty commit"
```

Then run the node and the prover using different commits.

> [!WARNING]
> Remember to run `make build-prover` whenever you change the commit

Closes #3311

Author: avilagaston9

Cargo.lock

@@ -105,4 +105,5 @@ name = "build_block_benchmark"
 harness = false
 
 [build-dependencies]
-vergen = { version = "9.0.0", features = ["rustc"] }
+vergen-git2 = { version = "1.0.7", features = ["rustc"] }
+

cmd/ethrex/Cargo.toml

@@ -1,14 +1,25 @@
 use std::error::Error;
-use vergen::{Emitter, RustcBuilder};
+use vergen_git2::{Emitter, Git2Builder, RustcBuilder};
 
 // This build code is needed to add some env vars in order to construct the node client version
-// VERGEN_RUSTC_COMMIT_HASH to get the commit hash
 // VERGEN_RUSTC_HOST_TRIPLE to get the build OS
 // VERGEN_RUSTC_SEMVER to get the rustc version
+// VERGEN_GIT_BRANCH to get the git branch name
+// VERGEN_GIT_SHA to get the git commit hash
 
 fn main() -> Result<(), Box<dyn Error>> {
-    let rustc = RustcBuilder::all_rustc()?;
+    // Export build OS and rustc version as environment variables
+    let rustc = RustcBuilder::default()
+        .semver(true)
+        .host_triple(true)
+        .build()?;
 
-    Emitter::default().add_instructions(&rustc)?.emit()?;
+    // Export git commit hash and branch name as environment variables
+    let git2 = Git2Builder::default().branch(true).sha(true).build()?;
+
+    Emitter::default()
+        .add_instructions(&rustc)?
+        .add_instructions(&git2)?
+        .emit()?;
     Ok(())
 }

cmd/ethrex/build.rs

@@ -153,10 +153,11 @@ pub fn parse_hex(s: &str) -> eyre::Result<Bytes, FromHexError> {
 
 pub fn get_client_version() -> String {
     format!(
-        "{}/v{}-develop-{}/{}/rustc-v{}",
+        "{}/v{}-{}-{}/{}/rustc-v{}",
         env!("CARGO_PKG_NAME"),
         env!("CARGO_PKG_VERSION"),
-        &env!("VERGEN_RUSTC_COMMIT_HASH")[0..6],
+        env!("VERGEN_GIT_BRANCH"),
+        env!("VERGEN_GIT_SHA"),
         env!("VERGEN_RUSTC_HOST_TRIPLE"),
         env!("VERGEN_RUSTC_SEMVER")
     )

cmd/ethrex/utils.rs

@@ -51,6 +51,9 @@ zkvm_interface = { path = "./prover/zkvm/interface/" }
 [dev-dependencies]
 rand = "0.8.5"
 
+[build-dependencies]
+vergen-git2 = { version = "1.0.7"}
+
 [lib]
 path = "./l2.rs"
 

crates/l2/Cargo.toml

@@ -0,0 +1,13 @@
+use std::error::Error;
+use vergen_git2::{Emitter, Git2Builder};
+
+// This build code is needed to add some env vars in order to construct the code version
+// VERGEN_GIT_SHA to get the git commit hash
+
+fn main() -> Result<(), Box<dyn Error>> {
+    // Export git commit hash and branch name as environment variables
+    let git2 = Git2Builder::default().sha(true).build()?;
+
+    Emitter::default().add_instructions(&git2)?.emit()?;
+    Ok(())
+}

crates/l2/build.rs

@@ -2,6 +2,7 @@
 name = "ethrex-prover"
 version.workspace = true
 edition.workspace = true
+build = "build.rs"
 
 [dependencies]
 serde_json.workspace = true
@@ -42,6 +43,9 @@ sp1-recursion-gnark-ffi = { version = "5.0.0", optional = true }
 [dev-dependencies]
 ethrex-storage.workspace = true
 
+[build-dependencies]
+vergen-git2 = { version = "1.0.7"}
+
 [lib]
 name = "ethrex_prover_lib"
 path = "src/lib.rs"

crates/l2/prover/Cargo.toml

@@ -0,0 +1,13 @@
+use std::error::Error;
+use vergen_git2::{Emitter, Git2Builder};
+
+// This build code is needed to add some env vars in order to construct the code version
+// VERGEN_GIT_SHA to get the git commit hash
+
+fn main() -> Result<(), Box<dyn Error>> {
+    // Export git commit hash and branch name as environment variables
+    let git2 = Git2Builder::default().sha(true).build()?;
+
+    Emitter::default().add_instructions(&git2)?.emit()?;
+    Ok(())
+}

crates/l2/prover/build.rs

@@ -1,5 +1,5 @@
 use crate::{config::ProverConfig, prove, to_batch_proof};
-use ethrex_l2::sequencer::proof_coordinator::ProofData;
+use ethrex_l2::sequencer::proof_coordinator::{ProofData, get_commit_hash};
 use ethrex_l2_common::prover::BatchProof;
 use std::time::Duration;
 use tokio::{
@@ -24,6 +24,7 @@ struct Prover {
     prover_server_endpoint: String,
     proving_time_ms: u64,
     aligned_mode: bool,
+    commit_hash: String,
 }
 
 impl Prover {
@@ -32,6 +33,7 @@ impl Prover {
             prover_server_endpoint: format!("{}:{}", cfg.http_addr, cfg.http_port),
             proving_time_ms: cfg.proving_time_ms,
             aligned_mode: cfg.aligned_mode,
+            commit_hash: get_commit_hash(),
         }
     }
 
@@ -43,10 +45,15 @@ impl Prover {
             let Ok(prover_data) = self
                 .request_new_input()
                 .await
-                .inspect_err(|e| warn!("Failed to request new data: {e}"))
+                .inspect_err(|e| error!("Failed to request new data: {e}"))
             else {
                 continue;
             };
+
+            let Some(prover_data) = prover_data else {
+                continue;
+            };
+
             // If we get the input
             // Generate the Proof
             let Ok(batch_proof) = prove(prover_data.input, self.aligned_mode)
@@ -65,30 +72,36 @@ impl Prover {
         }
     }
 
-    async fn request_new_input(&self) -> Result<ProverData, String> {
+    async fn request_new_input(&self) -> Result<Option<ProverData>, String> {
         // Request the input with the correct batch_number
-        let request = ProofData::batch_request();
+        let request = ProofData::batch_request(self.commit_hash.clone());
         let response = connect_to_prover_server_wr(&self.prover_server_endpoint, &request)
             .await
             .map_err(|e| format!("Failed to get Response: {e}"))?;
 
-        let ProofData::BatchResponse {
-            batch_number,
-            input,
-        } = response
-        else {
-            return Err("Expecting ProofData::Response".to_owned());
+        let (batch_number, input) = match response {
+            ProofData::BatchResponse {
+                batch_number,
+                input,
+            } => (batch_number, input),
+            ProofData::InvalidCodeVersion { commit_hash } => {
+                return Err(format!(
+                    "Invalid code version received. Server commit_hash: {}, Prover commit_hash: {}",
+                    commit_hash, self.commit_hash
+                ));
+            }
+            _ => return Err("Expecting ProofData::Response".to_owned()),
         };
 
         let (Some(batch_number), Some(input)) = (batch_number, input) else {
-            return Err(
-                    "Received Empty Response, meaning that the ProverServer doesn't have batches to prove.\nThe Prover may be advancing faster than the Proposer."
-                        .to_owned(),
-                );
+            warn!(
+                "Received Empty Response, meaning that the ProverServer doesn't have batches to prove.\nThe Prover may be advancing faster than the Proposer."
+            );
+            return Ok(None);
         };
 
         info!("Received Response for batch_number: {batch_number}");
-        Ok(ProverData {
+        Ok(Some(ProverData {
             batch_number,
             input: ProgramInput {
                 blocks: input.blocks,
@@ -99,7 +112,7 @@ impl Prover {
                 #[cfg(feature = "l2")]
                 blob_proof: input.blob_proof,
             },
-        })
+        }))
     }
 
     async fn submit_proof(&self, batch_number: u64, batch_proof: BatchProof) -> Result<(), String> {