fix(l2): verify a single blob proof in the guest program (#5081)

**Motivation**

After Osaka, we (ethrex L2) as blob originators have to update our
approach to constructing blob transactions (see
[this](https://x.com/vdwijden/status/1978443940098457669?s=46&t=UeaOPcmE9dAwr9hxRE1oWQ))
and [include the cell blob proofs in the
bundle](#4814).

As a ZK rollup, in the guest program, we verify the blob construction,
but the zkVM libraries lack working functionality for verifying blob
cell proofs (we've created the following issues on SP1 and RISC0,
respectively succinctlabs/kzg-rs#28 and
risc0/risc0#3506).

**Description**

To avoid troubles with libraries, we opted to verify the blob the
old-fashioned way (pre-Osaka-like) in the guest program. This can be
done without any issue, since what's important in the guest program is
to compute the same blob versioned hash as the one that was committed on
the L1; how the blob is verified is independent of this.

This PR reverts the changes done to the prover crate in pos of verifying
cell proofs and updates the prover input generation to generate a single
blob proof for the prover.

Author: ilitteri

crates/l2/common/src/prover.rs

@@ -16,8 +16,8 @@ pub struct ProverInputData {
     pub elasticity_multiplier: u64,
     #[serde_as(as = "[_; 48]")]
     pub blob_commitment: blobs_bundle::Commitment,
-    #[serde_as(as = "Vec<[_; 48]>")]
-    pub blob_proofs: Vec<blobs_bundle::Proof>,
+    #[serde_as(as = "[_; 48]")]
+    pub blob_proof: blobs_bundle::Proof,
     pub fee_configs: Vec<FeeConfig>,
 }
 

crates/l2/prover/src/guest_program/src/execution.rs

@@ -105,7 +105,7 @@ pub fn execution_program(input: ProgramInput) -> Result<ProgramOutput, Stateless
         #[cfg(feature = "l2")]
         blob_commitment,
         #[cfg(feature = "l2")]
-        blob_proofs,
+        blob_proof,
     } = input;
 
     let chain_id = execution_witness.chain_config.chain_id;
@@ -118,7 +118,7 @@ pub fn execution_program(input: ProgramInput) -> Result<ProgramOutput, Stateless
             elasticity_multiplier,
             _fee_configs,
             blob_commitment,
-            blob_proofs,
+            blob_proof,
             chain_id,
         );
     }
@@ -162,7 +162,7 @@ pub fn stateless_validation_l2(
     elasticity_multiplier: u64,
     fee_configs: Option<Vec<FeeConfig>>,
     blob_commitment: Commitment,
-    blob_proof: Vec<Proof>,
+    blob_proof: Proof,
     chain_id: u64,
 ) -> Result<ProgramOutput, StatelessExecutionError> {
     let initial_db = execution_witness.clone();
@@ -195,7 +195,7 @@ pub fn stateless_validation_l2(
         )?;
 
     // TODO: this could be replaced with something like a ProverConfig in the future.
-    let validium = (blob_commitment, &blob_proof) == ([0; 48], &vec![[0; 48]]);
+    let validium = (blob_commitment, &blob_proof) == ([0; 48], &[0; 48]);
 
     // Check state diffs are valid
     let blob_versioned_hash = if !validium {
@@ -467,22 +467,14 @@ fn compute_l1messages_and_privileged_transactions_digests(
 fn verify_blob(
     state_diff: StateDiff,
     commitment: Commitment,
-    proof: Vec<Proof>,
+    proof: Proof,
 ) -> Result<H256, StatelessExecutionError> {
-    use ethrex_crypto::kzg::{verify_blob_kzg_proof, verify_cell_kzg_proof_batch};
+    use ethrex_crypto::kzg::verify_blob_kzg_proof;
 
     let encoded_state_diff = state_diff.encode()?;
     let blob_data = blob_from_bytes(encoded_state_diff)?;
 
-    let proof_is_valid = if proof.len() == 1 {
-        // Prior to Osaka type proof
-        verify_blob_kzg_proof(blob_data, commitment, proof[0])?
-    } else {
-        // Osaka type proof
-        verify_cell_kzg_proof_batch(&[blob_data], &[commitment], &proof)?
-    };
-
-    if !proof_is_valid {
+    if !verify_blob_kzg_proof(blob_data, commitment, proof)? {
         return Err(StatelessExecutionError::InvalidBlobProof);
     }
 

crates/l2/prover/src/guest_program/src/input.rs

@@ -26,8 +26,8 @@ pub struct ProgramInput {
     pub blob_commitment: blobs_bundle::Commitment,
     #[cfg(feature = "l2")]
     /// KZG opening for a challenge over the blob commitment
-    #[serde_as(as = "Vec<[_; 48]>")]
-    pub blob_proofs: Vec<blobs_bundle::Proof>,
+    #[serde_as(as = "[_; 48]")]
+    pub blob_proof: blobs_bundle::Proof,
 }
 
 impl Default for ProgramInput {
@@ -40,7 +40,7 @@ impl Default for ProgramInput {
             #[cfg(feature = "l2")]
             blob_commitment: [0; 48],
             #[cfg(feature = "l2")]
-            blob_proofs: vec![[0u8; 48]],
+            blob_proof: [0u8; 48],
         }
     }
 }

crates/l2/prover/src/prover.rs

@@ -129,7 +129,7 @@ impl Prover {
                 #[cfg(feature = "l2")]
                 blob_commitment: input.blob_commitment,
                 #[cfg(feature = "l2")]
-                blob_proofs: input.blob_proofs,
+                blob_proof: input.blob_proof,
                 fee_configs: Some(input.fee_configs),
             },
         }))

crates/l2/sequencer/l1_committer.rs

@@ -14,9 +14,9 @@ use ethrex_blockchain::{Blockchain, vm::StoreVmDatabase};
 use ethrex_common::{
     Address, H256, U256,
     types::{
-        AccountUpdate, BLOB_BASE_FEE_UPDATE_FRACTION, BlobsBundle, Block, BlockNumber,
-        CELLS_PER_EXT_BLOB, Fork, Genesis, MIN_BASE_FEE_PER_BLOB_GAS, TxType, batch::Batch,
-        blobs_bundle, fake_exponential_checked,
+        AccountUpdate, BLOB_BASE_FEE_UPDATE_FRACTION, BlobsBundle, Block, BlockNumber, Fork,
+        Genesis, MIN_BASE_FEE_PER_BLOB_GAS, TxType, batch::Batch, blobs_bundle,
+        fake_exponential_checked,
     },
 };
 use ethrex_l2_common::{
@@ -707,37 +707,42 @@ impl L1Committer {
         // 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], vec![[0; 48]])
+            ([0; 48], [0; 48])
         } else {
             let BlobsBundle {
                 commitments,
                 proofs,
+                blobs,
                 ..
             } = &batch.blobs_bundle;
 
             let l1_fork = get_l1_active_fork(&self.eth_client, self.osaka_activation_time)
                 .await
                 .map_err(CommitterError::EthClientError)?;
-            let proof_count = if l1_fork < Fork::Osaka {
-                1
-            } else {
-                CELLS_PER_EXT_BLOB
-            };
+
             let commitment = commitments
                 .last()
                 .cloned()
                 .ok_or_else(|| CommitterError::MissingBlob(batch.number))?;
 
-            if proofs.len() != proof_count {
-                return Err(CommitterError::MissingBlob(batch.number));
-            }
-
-            let proof = proofs
-                .iter()
-                .rev()
-                .take(proof_count)
-                .cloned()
-                .collect::<Vec<_>>();
+            // The prover takes a single proof even for Osaka type proofs, so if
+            // the committer generated Osaka type proofs (cell proofs), we need
+            // to create a BlobsBundle from the blobs specifying a pre-Osaka
+            // fork to get a single proof for the entire blob.
+            // If we are pre-Osaka, we already have a single proof in the
+            // previously generated bundle
+            let proof = if l1_fork < Fork::Osaka {
+                proofs
+                    .first()
+                    .cloned()
+                    .ok_or_else(|| CommitterError::MissingBlob(batch.number))?
+            } else {
+                BlobsBundle::create_from_blobs(blobs, Some(0))?
+                    .proofs
+                    .first()
+                    .cloned()
+                    .ok_or_else(|| CommitterError::MissingBlob(batch.number))?
+            };
 
             (commitment, proof)
         };
@@ -747,7 +752,7 @@ impl L1Committer {
             execution_witness: batch_witness,
             elasticity_multiplier: self.elasticity_multiplier,
             blob_commitment,
-            blob_proofs: blob_proof,
+            blob_proof,
             fee_configs,
         };
 

crates/l2/tee/quote-gen/src/sender.rs

@@ -32,7 +32,7 @@ pub async fn get_batch(commit_hash: String) -> Result<(u64, ProgramInput), Strin
                     #[cfg(feature = "l2")]
                     blob_commitment: input.blob_commitment,
                     #[cfg(feature = "l2")]
-                    blob_proofs: input.blob_proofs,
+                    blob_proof: input.blob_proof,
                     fee_configs: Some(input.fee_configs),
                 },
             )),