add comments and add staleness check and empty bytes check

crates/eigenda/src/eigenda.rs

@@ -4,6 +4,8 @@
 use crate::eigenda_blobs::EigenDABlobSource;
 use crate::errors::CodecError;
 use crate::traits::EigenDABlobProvider;
+use crate::BlobInfo;
+use alloy_rlp::Decodable;
 
 use alloc::{boxed::Box, fmt::Debug};
 use alloy_primitives::Bytes;
@@ -59,12 +61,28 @@ where
 
     async fn next(&mut self, block_ref: &BlockInfo) -> PipelineResult<Self::Item> {
         // then acutally use ethereum da to fetch. items are Bytes
-        let item = self.ethereum_source.next(block_ref).await?;
+        let cert = self.ethereum_source.next(block_ref).await?;
 
-        // just dump all the data out
-        info!(target: "eth-datasource", "next item {:?}", item);
+        // verify if cert is too stale
+        let cert_blob_info = BlobInfo::decode(&mut &cert.as_ref()[4..]).unwrap();
+        info!("cert_blob_info {:?}", cert_blob_info);
+        let rbn = cert_blob_info
+            .blob_verification_proof
+            .batch_medatada
+            .batch_header
+            .reference_block_number as u64;
+        let l1_block_number = block_ref.number;
 
-        let eigenda_blob = self.eigenda_source.next(&item).await?;
+        // ToDo make it part of rollup config
+        let stale_gap = 100 as u64;
+
+        // check staleness
+        if rbn + stale_gap < l1_block_number {
+            // return error
+            unimplemented!()
+        }
+
+        let eigenda_blob = self.eigenda_source.next(&cert).await?;
         Ok(eigenda_blob)
     }
 

crates/eigenda/src/eigenda_data.rs

@@ -36,6 +36,8 @@ impl EigenDABlobData {
             helpers::remove_empty_byte_from_padded_bytes_unchecked(codec_data.as_ref());
         let blob_content: Bytes = blob_content.into();
 
+        // might insert a FFT here,
+
         // take data
         Ok(blob_content.slice(..content_size as usize))
     }

crates/proof/src/eigenda_provider.rs

@@ -3,7 +3,7 @@ use alloc::sync::Arc;
 use alloy_primitives::{keccak256, Bytes};
 use async_trait::async_trait;
 use hokulea_eigenda::{BlobInfo, EigenDABlobProvider};
-use kona_preimage::{CommsClient, PreimageKey, PreimageKeyType};
+use kona_preimage::{errors::PreimageOracleError, CommsClient, PreimageKey, PreimageKeyType};
 
 use kona_proof::errors::OracleProviderError;
 
@@ -37,45 +37,62 @@ impl<T: CommsClient + Sync + Send> EigenDABlobProvider for OracleEigenDAProvider
 
         // the fourth because 0x01010000 in the beginnin is metadata
         let item_slice = cert.as_ref();
+
+        // cert should at least contain 32 bytes for header + 4 bytes for commitment type metadata
+        if item_slice.len() <= 32 + 4 {
+            return Err(OracleProviderError::Preimage(PreimageOracleError::Other(
+                "does not contain header".into(),
+            )));
+        }
+
+        // the first four bytes are metadata, like cert version, OP generic commitement
+        // see https://github.com/Layr-Labs/eigenda-proxy/blob/main/commitments/mode.go#L39
+        // the first byte my guess is the OP
         let cert_blob_info = BlobInfo::decode(&mut &item_slice[4..]).unwrap();
         info!("cert_blob_info {:?}", cert_blob_info);
 
-        // hack - remove later, when cert actually contain length
-        let data = self
-            .oracle
-            .get(PreimageKey::new(
-                *keccak256(cert),
-                PreimageKeyType::GlobalGeneric,
-            ))
-            .await
-            .map_err(OracleProviderError::Preimage)?;
-
         let mut blob: Vec<u8> = vec![0; cert_blob_info.blob_header.data_length as usize];
 
         // 96 because our g1 commitment has 64 bytes in v1
-        let mut field_element_key = [0u8; 96];
-
-        // ToDo data_length should be power of 2, proxy should have returned it with dividing 32
+        // why 96, the original 4844 has bytes length of 80 (it has 48 bytes for commitment)
+        // even then, it is not that the entire 80 bytes are used. Some bytes are empty
+        // for solidity optimization, I remember.
+        //
+        // ToDo investigate later to decide a right size
+        let mut blob_key = [0u8; 96];
+
+        // In eigenDA terminology, length describes the number of field element, size describes
+        // number of bytes. In eigenda proxy memstore mode, the datalength is wronly assigned to
+        // be the bytes lenght. We need to resolve it later.
+        // For now, we internally divides 32. ToDo
         let data_length = cert_blob_info.blob_header.data_length as u64 / 32;
 
         info!("cert_blob_info.blob_header.data_length {:?}", data_length);
 
-        field_element_key[..32].copy_from_slice(&cert_blob_info.blob_header.commitment.x);
-        field_element_key[32..64].copy_from_slice(&cert_blob_info.blob_header.commitment.y);
+        // the common key
+        blob_key[..32].copy_from_slice(&cert_blob_info.blob_header.commitment.x);
+        blob_key[32..64].copy_from_slice(&cert_blob_info.blob_header.commitment.y);
+
         for i in 0..data_length {
-            field_element_key[88..].copy_from_slice(i.to_be_bytes().as_ref());
+            blob_key[88..].copy_from_slice(i.to_be_bytes().as_ref());
 
             let mut field_element = [0u8; 32];
             self.oracle
                 .get_exact(
-                    PreimageKey::new(
-                        *keccak256(field_element_key),
-                        PreimageKeyType::GlobalGeneric,
-                    ),
+                    PreimageKey::new(*keccak256(blob_key), PreimageKeyType::GlobalGeneric),
                     &mut field_element,
                 )
                 .await
                 .map_err(OracleProviderError::Preimage)?;
+
+            // if field element is 0, it means the host has identified that the data
+            // has breached eigenda invariant, i.e cert is valid
+            if field_element.len() == 0 {
+                return Err(OracleProviderError::Preimage(PreimageOracleError::Other(
+                    "field elememnt is empty, breached eigenda invariant".into(),
+                )));
+            }
+
             blob[(i as usize) << 5..(i as usize + 1) << 5].copy_from_slice(field_element.as_ref());
         }