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

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),
                 },
             )),