feat(l2): generate batch prover input at commit and store it in db

crates/l2/common/Cargo.toml

@@ -12,12 +12,18 @@ ethrex-rlp.workspace = true
 ethrex-storage.workspace = true
 ethrex-trie.workspace = true
 ethrex-vm.workspace = true
+
 bytes.workspace = true
 thiserror.workspace = true
 serde.workspace = true
 lambdaworks-crypto.workspace = true
 sha3.workspace = true
 secp256k1.workspace = true
+serde_with.workspace = true
+# We do not need to enable the "unaligned" feature here since we are just using
+# rkyv for ProverInputData, a data structure meant to be used in the host and not
+# inside a guest program
+rkyv.workspace = true
 
 [lints.clippy]
 unwrap_used = "deny"

crates/l2/common/src/prover.rs

@@ -1,8 +1,26 @@
+use ethrex_common::types::{
+    Block, blobs_bundle, block_execution_witness::ExecutionWitness, fee_config::FeeConfig,
+};
+use rkyv::{Archive, Deserialize as RDeserialize, Serialize as RSerialize};
 use serde::{Deserialize, Serialize};
+use serde_with::serde_as;
 use std::fmt::{Debug, Display};
 
 use crate::calldata::Value;
 
+#[serde_as]
+#[derive(Serialize, Deserialize, RDeserialize, RSerialize, Archive)]
+pub struct ProverInputData {
+    pub blocks: Vec<Block>,
+    pub execution_witness: ExecutionWitness,
+    pub elasticity_multiplier: u64,
+    #[serde_as(as = "[_; 48]")]
+    pub blob_commitment: blobs_bundle::Commitment,
+    #[serde_as(as = "[_; 48]")]
+    pub blob_proof: blobs_bundle::Proof,
+    pub fee_config: FeeConfig,
+}
+
 /// Enum used to identify the different proving systems.
 #[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, Serialize, Deserialize)]
 pub enum ProverType {

crates/l2/constants.rs

@@ -0,0 +1 @@
+pub const BIN_VERSION: &str = env!("CARGO_PKG_VERSION");

crates/l2/l2.rs

@@ -1,4 +1,5 @@
 pub mod based;
+pub mod constants;
 pub mod errors;
 pub mod monitor;
 pub mod sequencer;

crates/l2/prover/src/prover.rs

@@ -1,5 +1,8 @@
 use crate::{backend::Backend, config::ProverConfig, prove, to_batch_proof};
-use ethrex_l2::sequencer::proof_coordinator::{ProofData, get_commit_hash};
+use ethrex_l2::{
+    constants::BIN_VERSION,
+    sequencer::proof_coordinator::{ProofData, get_commit_hash},
+};
 use ethrex_l2_common::prover::BatchProof;
 use guest_program::input::ProgramInput;
 use std::time::Duration;
@@ -92,7 +95,7 @@ impl Prover {
 
     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());
+        let request = ProofData::batch_request(self.commit_hash.clone(), BIN_VERSION.to_string());
         let response = connect_to_prover_server_wr(endpoint, &request)
             .await
             .map_err(|e| format!("Failed to get Response: {e}"))?;

crates/l2/sequencer/errors.rs

@@ -121,6 +121,8 @@ pub enum ProofCoordinatorError {
     MissingTDXPrivateKey,
     #[error("Metrics error")]
     Metrics(#[from] MetricsError),
+    #[error("Missing prover input for batch {0} (version {1})")]
+    MissingBatchProverInput(u64, String),
 }
 
 #[derive(Debug, thiserror::Error)]
@@ -261,6 +263,8 @@ pub enum CommitterError {
     UnexpectedError(String),
     #[error("Unreachable code reached: {0}")]
     Unreachable(String),
+    #[error("Failed to generate batch witness: {0}")]
+    FailedToGenerateBatchWitness(#[source] ChainError),
 }
 
 #[derive(Debug, thiserror::Error)]

crates/l2/sequencer/l1_committer.rs

@@ -1,14 +1,15 @@
 use crate::{
-    CommitterConfig, EthConfig, SequencerConfig,
+    BlockProducerConfig, CommitterConfig, EthConfig, SequencerConfig,
     based::sequencer_state::{SequencerState, SequencerStatus},
+    constants::BIN_VERSION,
     sequencer::{
         errors::CommitterError,
-        utils::{self, system_now_ms},
+        utils::{self, fetch_batch_blocks, system_now_ms},
     },
 };
 
 use bytes::Bytes;
-use ethrex_blockchain::{Blockchain, vm::StoreVmDatabase};
+use ethrex_blockchain::{Blockchain, BlockchainType, vm::StoreVmDatabase};
 use ethrex_common::{
     Address, H256, U256,
     types::{
@@ -24,6 +25,7 @@ use ethrex_l2_common::{
         PRIVILEGED_TX_BUDGET, compute_privileged_transactions_hash,
         get_block_privileged_transactions,
     },
+    prover::ProverInputData,
     state_diff::{StateDiff, prepare_state_diff},
 };
 use ethrex_l2_rpc::signer::{Signer, SignerHealth};
@@ -103,6 +105,7 @@ pub struct L1Committer {
     last_committed_batch: u64,
     /// Cancellation token for the next inbound InMessage::Commit
     cancellation_token: Option<CancellationToken>,
+    elasticity_multiplier: u64,
 }
 
 #[derive(Clone, Serialize)]
@@ -125,6 +128,7 @@ impl L1Committer {
     #[allow(clippy::too_many_arguments)]
     pub async fn new(
         committer_config: &CommitterConfig,
+        proposer_config: &BlockProducerConfig,
         eth_config: &EthConfig,
         blockchain: Arc<Blockchain>,
         store: Store,
@@ -163,6 +167,7 @@ impl L1Committer {
             last_committed_batch_timestamp: 0,
             last_committed_batch,
             cancellation_token: None,
+            elasticity_multiplier: proposer_config.elasticity_multiplier,
         })
     }
 
@@ -175,6 +180,7 @@ impl L1Committer {
     ) -> Result<GenServerHandle<L1Committer>, CommitterError> {
         let state = Self::new(
             &cfg.l1_committer,
+            &cfg.block_producer,
             &cfg.eth,
             blockchain,
             store.clone(),
@@ -264,6 +270,15 @@ impl L1Committer {
             }
         };
 
+        info!(
+            first_block = batch.first_block,
+            last_block = batch.last_block,
+            "Generating and storing witness for batch {}",
+            batch.number,
+        );
+
+        self.generate_and_store_batch_prover_input(&batch).await?;
+
         info!(
             first_block = batch.first_block,
             last_block = batch.last_block,
@@ -536,6 +551,69 @@ impl L1Committer {
         ))
     }
 
+    async fn generate_and_store_batch_prover_input(
+        &self,
+        batch: &Batch,
+    ) -> Result<(), CommitterError> {
+        let blocks = self.fetch_batch_blocks(batch).await?;
+
+        let batch_witness = self
+            .blockchain
+            .generate_witness_for_blocks(&blocks)
+            .await
+            .map_err(CommitterError::FailedToGenerateBatchWitness)?;
+
+        // We still need to differentiate the validium case because for validium
+        // we are generating the BlobsBundle with BlobsBundle::default which
+        // sets the commitments and proofs to empty vectors.
+        let (blob_commitment, blob_proof) = if self.validium {
+            ([0; 48], [0; 48])
+        } else {
+            let BlobsBundle {
+                commitments,
+                proofs,
+                ..
+            } = &batch.blobs_bundle;
+
+            (
+                commitments
+                    .first()
+                    .cloned()
+                    .ok_or(CommitterError::Unreachable(
+                        "Blob commitment missing in batch blobs bundle".to_string(),
+                    ))?,
+                proofs.first().cloned().ok_or(CommitterError::Unreachable(
+                    "Blob proof missing in batch blobs bundle".to_string(),
+                ))?,
+            )
+        };
+
+        let BlockchainType::L2(fee_config) = self.blockchain.options.r#type else {
+            return Err(CommitterError::Unreachable(
+                "Batch witness generation is only supported for L2 blockchains".to_string(),
+            ));
+        };
+
+        let prover_input = ProverInputData {
+            blocks,
+            execution_witness: batch_witness,
+            elasticity_multiplier: self.elasticity_multiplier,
+            blob_commitment,
+            blob_proof,
+            fee_config,
+        };
+
+        self.rollup_store
+            .store_prover_input_by_batch_and_version(
+                batch.number,
+                BIN_VERSION.to_string(),
+                prover_input,
+            )
+            .await?;
+
+        Ok(())
+    }
+
     async fn send_commitment(&mut self, batch: &Batch) -> Result<H256, CommitterError> {
         let messages_merkle_root = compute_merkle_root(&batch.message_hashes);
         let last_block_hash = get_last_block_hash(&self.store, batch.last_block)?;
@@ -551,22 +629,9 @@ impl L1Committer {
         let (commit_function_signature, values) = if self.based {
             let mut encoded_blocks: Vec<Bytes> = Vec::new();
 
-            for i in batch.first_block..=batch.last_block {
-                let block_header = self
-                    .store
-                    .get_block_header(i)
-                    .map_err(CommitterError::from)?
-                    .ok_or(CommitterError::FailedToRetrieveDataFromStorage)?;
-
-                let block_body = self
-                    .store
-                    .get_block_body(i)
-                    .await
-                    .map_err(CommitterError::from)?
-                    .ok_or(CommitterError::FailedToRetrieveDataFromStorage)?;
-
-                let block = Block::new(block_header, block_body);
+            let blocks = self.fetch_batch_blocks(batch).await?;
 
+            for block in blocks {
                 encoded_blocks.push(block.encode_to_vec().into());
             }
 
@@ -664,6 +729,10 @@ impl L1Committer {
         Ok(commit_tx_hash)
     }
 
+    async fn fetch_batch_blocks(&self, batch: &Batch) -> Result<Vec<Block>, CommitterError> {
+        fetch_batch_blocks(batch.number, &self.store, &self.rollup_store).await
+    }
+
     fn stop_committer(&mut self) -> CallResponse<Self> {
         if let Some(token) = self.cancellation_token.take() {
             token.cancel();
@@ -747,7 +816,7 @@ impl GenServer for L1Committer {
             let commit_time: u128 = self.commit_time_ms.into();
             let should_send_commitment =
                 current_time - self.last_committed_batch_timestamp > commit_time;
-            #[allow(clippy::collapsible_if)]
+            #[expect(clippy::collapsible_if)]
             if should_send_commitment {
                 if self
                     .commit_next_batch_to_l1()

crates/l2/sequencer/mod.rs

@@ -110,10 +110,8 @@ pub async fn start_l2(
         error!("Error starting Committer: {err}");
     });
     let _ = ProofCoordinator::spawn(
-        store.clone(),
         rollup_store.clone(),
         cfg.clone(),
-        blockchain.clone(),
         needed_proof_types.clone(),
     )
     .await