add cert version and multiplex cert handling

crates/eigenda/src/eigenda.rs

@@ -88,12 +88,14 @@ where
 
                 let eigenda_blob = self.eigenda_source.next(&cert).await?;
                 Ok(eigenda_blob)
-            },
+            }
             CertVersion::Version2 => {
                 // TODO if punctuality is checked elsewhere, then we don't need to deserialize here
-                let eigenda_v2_cert = match EigenDAV2Cert::decode(&mut &cert.as_ref()[4..]){
+                let eigenda_v2_cert = match EigenDAV2Cert::decode(&mut &cert.as_ref()[4..]) {
                     Ok(c) => c,
-                    Err(_e) => return Err(PipelineErrorKind::Temporary(PipelineError::EndOfSource)),
+                    Err(_e) => {
+                        return Err(PipelineErrorKind::Temporary(PipelineError::EndOfSource))
+                    }
                 };
                 let rbn = eigenda_v2_cert.batch_header_v2.reference_block_number as u64;
                 // check staleness
@@ -106,10 +108,10 @@ where
                 }
                 let eigenda_blob = self.eigenda_source.next(&cert).await?;
                 Ok(eigenda_blob)
-            },
+            }
             CertVersion::Unknown => {
                 return Err(PipelineErrorKind::Temporary(PipelineError::EndOfSource));
-            },
+            }
         }
     }
 

crates/eigenda/src/eigenda_blobs.rs

@@ -1,9 +1,9 @@
 //! Blob Data Source
 
-use crate::{eigenda_data::EigenDABlobData, CertVersion};
 use crate::traits::EigenDABlobProvider;
-use eigenda_v2_struct_rust::EigenDAV2Cert;
+use crate::{eigenda_data::EigenDABlobData, CertVersion};
 use alloy_rlp::Decodable;
+use eigenda_v2_struct_rust::EigenDAV2Cert;
 
 use alloc::vec::Vec;
 use alloy_primitives::Bytes;
@@ -74,8 +74,9 @@ where
         let data = match cert_version {
             CertVersion::Version1 => self.eigenda_fetcher.get_blob(eigenda_commitment).await,
             CertVersion::Version2 => {
-                let eigenda_v2_cert = EigenDAV2Cert::decode(&mut &eigenda_commitment.as_ref()[4..]).unwrap();
-                self.eigenda_fetcher.get_blob_v2(&eigenda_v2_cert).await            
+                let eigenda_v2_cert =
+                    EigenDAV2Cert::decode(&mut &eigenda_commitment.as_ref()[4..]).unwrap();
+                self.eigenda_fetcher.get_blob_v2(&eigenda_v2_cert).await
             }
             CertVersion::Unknown => panic!("impossible to trigger"),
         };
@@ -84,7 +85,9 @@ where
             Ok(data) => {
                 self.open = true;
                 let new_blob: Vec<u8> = data.into();
-                let eigenda_blob = EigenDABlobData { blob: new_blob.into() };
+                let eigenda_blob = EigenDABlobData {
+                    blob: new_blob.into(),
+                };
                 self.data.push(eigenda_blob);
 
                 info!(target: "eigenda-blobsource", "load_blobs {:?}", self.data);

crates/eigenda/src/lib.rs

@@ -37,4 +37,3 @@ mod constant;
 pub use constant::BLOB_ENCODING_VERSION_0;
 pub use constant::BYTES_PER_FIELD_ELEMENT;
 pub use constant::STALE_GAP;
-

crates/eigenda/src/traits.rs

@@ -2,8 +2,8 @@ use alloc::{boxed::Box, string::ToString};
 use alloy_primitives::Bytes;
 use async_trait::async_trait;
 use core::fmt::Display;
-use kona_derive::errors::PipelineErrorKind;
 use eigenda_v2_struct_rust::EigenDAV2Cert;
+use kona_derive::errors::PipelineErrorKind;
 use rust_kzg_bn254_primitives::blob::Blob;
 
 /// A trait for providing EigenDA blobs.

crates/eigenda/src/version.rs

@@ -1,7 +1,7 @@
 #[derive(Debug, PartialEq, Copy, Clone)]
 /// Represents the cert version derived from rollup inbox
 /// The version is needed to decode the Cert from serialiezd bytes
-/// Once a valid blob is retrieved, both versions use the identical 
+/// Once a valid blob is retrieved, both versions use the identical
 /// logic to derive the rollup channel frame from eigenda blobs
 pub enum CertVersion {
     /// unknown
@@ -20,4 +20,4 @@ impl From<u8> for CertVersion {
             _ => Self::Unknown,
         }
     }
-}
+}

crates/proof/src/eigenda_provider.rs

@@ -105,7 +105,6 @@ impl<T: CommsClient + Sync + Send> EigenDABlobProvider for OracleEigenDAProvider
         Ok(blob.into())
     }
 
-
     /// get_blob_v2 takes a v2 cert type as opposed to bytes stream
     async fn get_blob_v2(&mut self, cert: &EigenDAV2Cert) -> Result<Blob, Self::Error> {
         let mut cert_rlp_bytes = Vec::<u8>::new();
@@ -117,18 +116,36 @@ impl<T: CommsClient + Sync + Send> EigenDABlobProvider for OracleEigenDAProvider
             .await
             .map_err(OracleProviderError::Preimage)?;
 
-        let blob_length = cert.blob_inclusion_info.blob_certificate.blob_header.commitment.length as usize;
+        let blob_length = cert
+            .blob_inclusion_info
+            .blob_certificate
+            .blob_header
+            .commitment
+            .length as usize;
 
         // data_length measurs in field element, multiply to get num bytes
-        let mut blob: Vec<u8> =
-            vec![0; blob_length * BYTES_PER_FIELD_ELEMENT];
+        let mut blob: Vec<u8> = vec![0; blob_length * BYTES_PER_FIELD_ELEMENT];
 
         // TODO: Investigate of using cert_rlp_bytes as key, instead of 96 bytes
         let mut blob_key = [0u8; 96];
 
         // the common key
-        let x: [u8; 32] = cert.blob_inclusion_info.blob_certificate.blob_header.commitment.commitment.x.to_be_bytes();
-        let y: [u8; 32] = cert.blob_inclusion_info.blob_certificate.blob_header.commitment.commitment.y.to_be_bytes();
+        let x: [u8; 32] = cert
+            .blob_inclusion_info
+            .blob_certificate
+            .blob_header
+            .commitment
+            .commitment
+            .x
+            .to_be_bytes();
+        let y: [u8; 32] = cert
+            .blob_inclusion_info
+            .blob_certificate
+            .blob_header
+            .commitment
+            .commitment
+            .y
+            .to_be_bytes();
 
         blob_key[..32].copy_from_slice(&x);
         blob_key[32..64].copy_from_slice(&y);
@@ -153,7 +170,7 @@ impl<T: CommsClient + Sync + Send> EigenDABlobProvider for OracleEigenDAProvider
                 )));
             }
 
-            blob[(i as usize) << 5..(i as usize + 1) << 5].copy_from_slice(field_element.as_ref());
+            blob[i << 5..(i + 1) << 5].copy_from_slice(field_element.as_ref());
         }
 
         Ok(Blob::new(&blob))

crates/proof/src/preloaded_eigenda_provider.rs

@@ -2,14 +2,14 @@ use crate::eigenda_blob_witness::EigenDABlobWitnessData;
 use alloy_primitives::{Bytes, FixedBytes, U256};
 use ark_bn254::{Fq, G1Affine};
 use ark_ff::PrimeField;
+use async_trait::async_trait;
 use eigenda_v2_struct_rust::EigenDAV2Cert;
 use hokulea_eigenda::EigenDABlobProvider;
-use kona_proof::errors::OracleProviderError;
 use kona_preimage::errors::PreimageOracleError;
+use kona_proof::errors::OracleProviderError;
 use rust_kzg_bn254_primitives::blob::Blob;
 use rust_kzg_bn254_verifier::batch;
 use tracing::info;
-use async_trait::async_trait;
 
 /// PreloadedEigenDABlobProvider ensures the following invariants
 /// (P0) Validate validity proof for eigenda cert is correct, regardless if cert itself is correct
@@ -79,7 +79,7 @@ impl EigenDABlobProvider for PreloadedEigenDABlobProvider {
     /// Return an error if cert does not match the immeditate next item
     async fn get_blob_v2(&mut self, cert: &EigenDAV2Cert) -> Result<Blob, Self::Error> {
         let (eigenda_cert, eigenda_blob) = self.entries.pop().unwrap();
-        if eigenda_cert == *cert {    
+        if eigenda_cert == *cert {
             Ok(eigenda_blob)
         } else {
             Err(OracleProviderError::Preimage(PreimageOracleError::Other(