Create witness and blob preloader

Cargo.toml

@@ -7,6 +7,7 @@ members = ["bin/*", "crates/*"]
 hokulea-client = { path = "bin/client", version = "0.1.0", default-features = false }
 hokulea-eigenda = { path = "crates/eigenda", version = "0.1.0", default-features = false }
 hokulea-proof = { path = "crates/proof", version = "0.1.0", default-features = false }
+hokulea-compute-kzg-proof = { path = "crates/compute-kzg-proof", version = "0.1.0", default-features = false }
 
 # Kona
 # We use git dependencies instead of version dependencies because Kona is moving very fast right now
@@ -63,13 +64,22 @@ reqwest = "0.12.12"
 async-trait = "0.1.85"
 linked_list_allocator = "0.10.5"
 bytes = "1.9.0"
+num = "0.4"
 
 # General
 sha2 = { version = "0.10.8", default-features = false }
 c-kzg = { version = "2.0.0", default-features = false }
 anyhow = { version = "1.0.95", default-features = false }
 thiserror = { version = "2.0.9", default-features = false }
-rust-kzg-bn254 = { version = "0.2.1", default-features = false }
+rust-kzg-bn254-primitives = { git = "https://github.com/Layr-Labs/rust-kzg-bn254", rev = "b3e532e9aad533009849755d5ad7b9578a16bfb2", default-features = false }
+rust-kzg-bn254-prover = { git = "https://github.com/Layr-Labs/rust-kzg-bn254", rev = "b3e532e9aad533009849755d5ad7b9578a16bfb2", default-features = false }
+rust-kzg-bn254-verifier = { git = "https://github.com/Layr-Labs/rust-kzg-bn254", rev = "b3e532e9aad533009849755d5ad7b9578a16bfb2", default-features = false }
+
+# EigenDA v2 struct
+eigenda-v2-struct-rust = { git = "https://github.com/bxue-l2/eigenda-v2-struct-rust", rev = "cdeaf4e6ed7c3d55e70bf97c2c04a5e056b780ef" }
+
+ark-bn254 = "0.5.0"
+ark-ff = { version = "0.5.0", features = ["parallel"] }
 
 # Tracing
 tracing-loki = "0.2.5"

README.md

@@ -2,6 +2,9 @@
 
 Hokulea is a library to provide the altda providers for a derivation pipeline built with [kona](https://github.com/anton-rs/kona) to understand eigenDA blobs, following the [kona book](https://anton-rs.github.io/kona/sdk/pipeline/providers.html#implementing-a-custom-data-availability-provider) recommendation (also see this [comment](https://github.com/anton-rs/kona/pull/862#issuecomment-2515038089)).
 
+### Download SRS points
+Hokulea host currently computes a challenge proof that validates the correctness of the eigenda blob against the provided kzg commitment. Such computation requires the host to have access to sufficient KZG SRS points.
+
 ### Running against devnet
 
 First start the devnet:
@@ -17,4 +20,4 @@ cd bin/client
 just run-client-native-against-devnet
 ```
 
-![](./hokulea.jpeg)
+![](./hokulea.jpeg)

bin/client/Cargo.toml

@@ -14,4 +14,4 @@ kona-executor.workspace = true
 
 hokulea-proof.workspace = true
 
-tracing.workspace = true
+tracing.workspace = true

bin/client/src/lib.rs

@@ -8,6 +8,7 @@ use kona_preimage::{
 };
 
 use alloc::sync::Arc;
+
 use core::fmt::Debug;
 use kona_executor::TrieDBProvider;
 use kona_proof::{

bin/host/Cargo.toml

@@ -8,6 +8,7 @@ edition = "2021"
 hokulea-proof.workspace = true
 hokulea-client.workspace = true
 hokulea-eigenda.workspace = true
+hokulea-compute-kzg-proof.workspace = true
 
 # Kona
 kona-preimage = { workspace = true, features = ["std"] }

bin/host/src/eigenda_fetcher/mod.rs

@@ -7,6 +7,7 @@ use alloy_provider::ReqwestProvider;
 use alloy_rlp::Decodable;
 use anyhow::{anyhow, Result};
 use core::panic;
+use hokulea_compute_kzg_proof::compute_kzg_proof;
 use hokulea_eigenda::BlobInfo;
 use hokulea_eigenda::EigenDABlobData;
 use hokulea_eigenda::BYTES_PER_FIELD_ELEMENT;
@@ -156,15 +157,15 @@ where
             let cert_blob_info = BlobInfo::decode(&mut &item_slice[4..]).unwrap();
 
             // Proxy should return a cert whose data_length measured in symbol (i.e. 32 Bytes)
-            let blob_length = cert_blob_info.blob_header.data_length as u64;
-            warn!("blob length: {:?}", blob_length);
+            let data_length = cert_blob_info.blob_header.data_length as u64;
+            warn!("data length: {:?}", data_length);
 
             let eigenda_blob = EigenDABlobData::encode(rollup_data.as_ref());
 
-            if eigenda_blob.blob.len() != blob_length as usize * BYTES_PER_FIELD_ELEMENT {
+            if eigenda_blob.blob.len() != data_length as usize * BYTES_PER_FIELD_ELEMENT {
                 return Err(
                     anyhow!("data size from cert  does not equal to reconstructed data codec_rollup_data_len {} blob size {}", 
-                        eigenda_blob.blob.len(), blob_length as usize * BYTES_PER_FIELD_ELEMENT));
+                        eigenda_blob.blob.len(), data_length as usize * BYTES_PER_FIELD_ELEMENT));
             }
 
             // Write all the field elements to the key-value store.
@@ -176,9 +177,9 @@ where
             blob_key[..32].copy_from_slice(cert_blob_info.blob_header.commitment.x.as_ref());
             blob_key[32..64].copy_from_slice(cert_blob_info.blob_header.commitment.y.as_ref());
 
-            trace!("cert_blob_info blob_length {:?}", blob_length);
+            trace!("cert_blob_info data_length {:?}", data_length);
 
-            for i in 0..blob_length {
+            for i in 0..data_length {
                 blob_key[88..].copy_from_slice(i.to_be_bytes().as_ref());
                 let blob_key_hash = keccak256(blob_key.as_ref());
 
@@ -192,21 +193,23 @@ where
                 )?;
             }
 
-            // TODO proof is at the random point, but we need to figure out where to generate
-            //
-            // Write the KZG Proof as the last element, needed for ZK
-            //blob_key[88..].copy_from_slice((blob_length).to_be_bytes().as_ref());
-            //let blob_key_hash = keccak256(blob_key.as_ref());
+            let kzg_proof = match compute_kzg_proof(&eigenda_blob.blob) {
+                Ok(p) => p,
+                Err(e) => return Err(anyhow!("cannot compute kzg proof {}", e)),
+            };
 
-            //kv_write_lock.set(
-            //    PreimageKey::new(*blob_key_hash, PreimageKeyType::Keccak256).into(),
-            //    blob_key.into(),
-            //)?;
+            // Write the KZG Proof as the last element, needed for ZK
+            blob_key[88..].copy_from_slice((data_length).to_be_bytes().as_ref());
+            let blob_key_hash = keccak256(blob_key.as_ref());
+            kv_write_lock.set(
+                PreimageKey::new(*blob_key_hash, PreimageKeyType::Keccak256).into(),
+                blob_key.into(),
+            )?;
             // proof to be done
-            //kv_write_lock.set(
-            //    PreimageKey::new(*blob_key_hash, PreimageKeyType::GlobalGeneric).into(),
-            //    [1, 2, 3].to_vec(),
-            //)?;
+            kv_write_lock.set(
+                PreimageKey::new(*blob_key_hash, PreimageKeyType::GlobalGeneric).into(),
+                kzg_proof.to_vec(),
+            )?;
         } else {
             panic!("Invalid hint type: {hint_type}. FetcherWithEigenDASupport.prefetch only supports EigenDACommitment hints.");
         }

crates/compute-kzg-proof/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "hokulea-compute-kzg-proof"
+version = "0.1.0"
+edition = "2021"
+
+
+[dependencies]
+rust-kzg-bn254-prover.workspace = true
+rust-kzg-bn254-primitives.workspace = true
+num.workspace = true
+
+alloy-primitives.workspace = true

crates/compute-kzg-proof/README.md

@@ -0,0 +1,5 @@
+# `compute-kzg-proof`
+
+This is the temporary crate for generating a kzg proof using eigenda blob. In the future, such proof is carried inside the blob header. Then this crate can be removed.
+
+This crate access filesystem, cannot be used in any fault proof or zk vm. 

crates/compute-kzg-proof/src/compute_kzg_proof.rs

@@ -0,0 +1,59 @@
+//! This is the temporary crate for generating a kzg proof using eigenda blob. In the future,
+//! such proof is carried inside the blob header. Then this crate can be removed. This crate access filesystem,
+//! cannot be used in any fault proof or zk vm.
+extern crate alloc;
+use alloc::vec::Vec;
+use alloy_primitives::Bytes;
+use num::BigUint;
+use rust_kzg_bn254_primitives::blob::Blob;
+use rust_kzg_bn254_primitives::errors::KzgError;
+use rust_kzg_bn254_prover::kzg::KZG;
+use rust_kzg_bn254_prover::srs::SRS;
+
+/// This function computes a KZG proof for a eigenDA blob
+/// In the future, the eigenda blob header would contain the proof such that it does not require local computation
+/// nitro code <https://github.com/Layr-Labs/nitro/blob/14f09745b74321f91d1f702c3e7bb5eb7d0e49ce/arbitrator/prover/src/kzgbn254.rs#L141>
+/// could refactor in the future, such that both host and client can compute the proof
+pub fn compute_kzg_proof(blob: &[u8]) -> Result<Bytes, KzgError> {
+    // In the future, it might make sense to let the proxy to return kzg proof, instead of local computation
+    let srs = SRS::new("resources/g1.32mb.point", 268435456, 1024).unwrap();
+    let mut kzg = KZG::new();
+
+    let input = Blob::new(blob);
+    let input_poly = input.to_polynomial_eval_form();
+
+    kzg.calculate_and_store_roots_of_unity(blob.len() as u64)
+        .unwrap();
+
+    let mut commitment_bytes = vec![0u8; 0];
+
+    let commitment = kzg.commit_eval_form(&input_poly, &srs)?;
+
+    // TODO the library should have returned the bytes, or provide a helper
+    // for conversion. For both proof and commitment
+    let commitment_x_bigint: BigUint = commitment.x.into();
+    let commitment_y_bigint: BigUint = commitment.y.into();
+
+    append_left_padded_biguint_be(&mut commitment_bytes, &commitment_x_bigint);
+    append_left_padded_biguint_be(&mut commitment_bytes, &commitment_y_bigint);
+
+    let mut proof_bytes = vec![0u8; 0];
+
+    let proof = kzg.compute_blob_proof(&input, &commitment, &srs)?;
+    let proof_x_bigint: BigUint = proof.x.into();
+    let proof_y_bigint: BigUint = proof.y.into();
+
+    append_left_padded_biguint_be(&mut proof_bytes, &proof_x_bigint);
+    append_left_padded_biguint_be(&mut proof_bytes, &proof_y_bigint);
+
+    // push data into witness
+    Ok(proof_bytes.into())
+}
+
+/// This function convert a BigUint into 32Bytes vector in big endian format
+pub fn append_left_padded_biguint_be(vec: &mut Vec<u8>, biguint: &BigUint) {
+    let bytes = biguint.to_bytes_be();
+    let padding = 32 - bytes.len();
+    vec.extend(std::iter::repeat_n(0, padding));
+    vec.extend_from_slice(&bytes);
+}

crates/compute-kzg-proof/src/lib.rs

@@ -0,0 +1,14 @@
+#![doc = include_str!("../README.md")]
+#![warn(
+    missing_debug_implementations,
+    missing_docs,
+    unreachable_pub,
+    rustdoc::all
+)]
+#![deny(unused_must_use, rust_2018_idioms)]
+#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+#![cfg_attr(not(test), warn(unused_crate_dependencies))]
+
+pub mod compute_kzg_proof;
+
+pub use compute_kzg_proof::compute_kzg_proof;

crates/eigenda/Cargo.toml

@@ -12,7 +12,7 @@ alloy-rlp.workspace = true
 tracing.workspace = true
 async-trait.workspace = true
 bytes.workspace = true
-rust-kzg-bn254.workspace = true
+rust-kzg-bn254-primitives.workspace = true
 maili-protocol.workspace = true
 
 [features]

crates/eigenda/src/eigenda_data.rs

@@ -3,7 +3,7 @@ use alloc::vec;
 use alloy_primitives::Bytes;
 use bytes::buf::Buf;
 use kona_derive::errors::BlobDecodingError;
-use rust_kzg_bn254::helpers;
+use rust_kzg_bn254_primitives::helpers;
 
 #[derive(Default, Clone, Debug)]
 /// Represents the data structure for EigenDA Blob.

crates/eigenda/src/traits.rs

@@ -13,7 +13,4 @@ pub trait EigenDABlobProvider {
 
     /// Fetches a blob.
     async fn get_blob(&mut self, cert: &Bytes) -> Result<Bytes, Self::Error>;
-
-    /// Fetches an element from a blob.
-    async fn get_element(&mut self, cert: &Bytes, element: &Bytes) -> Result<Bytes, Self::Error>;
 }

crates/proof/Cargo.toml

@@ -12,6 +12,13 @@ kona-derive.workspace = true
 
 hokulea-eigenda.workspace = true
 
+eigenda-v2-struct-rust.workspace = true
+rust-kzg-bn254-primitives.workspace = true
+rust-kzg-bn254-verifier.workspace = true
+
+ark-bn254.workspace = true
+ark-ff.workspace = true
+
 # Alloy
 alloy-primitives.workspace = true
 

crates/proof/src/eigenda_blob_witness.rs

@@ -0,0 +1,33 @@
+extern crate alloc;
+use alloc::vec::Vec;
+use alloy_primitives::Bytes;
+
+use eigenda_v2_struct_rust::EigenDAV2Cert;
+use rust_kzg_bn254_primitives::blob::Blob;
+
+/// stores  
+#[derive(Debug, Clone, Default)]
+pub struct EigenDABlobWitnessData {
+    /// eigenda v2 cert
+    pub eigenda_certs: Vec<EigenDAV2Cert>,
+    /// blob empty if cert is invalid
+    pub eigenda_blobs: Vec<Blob>,
+    /// kzg proof on Fiat Shamir points
+    pub kzg_proofs: Vec<Bytes>,
+    /// a zk proof attesting the Cert is valid
+    /// each element is a tuple indicating
+    /// (validity, proof for validity) regardless of
+    /// validity is true or false
+    pub validity_proofs: Vec<(bool, Bytes)>,
+}
+
+impl EigenDABlobWitnessData {
+    pub fn new() -> Self {
+        EigenDABlobWitnessData {
+            eigenda_certs: Vec::new(),
+            eigenda_blobs: Vec::new(),
+            kzg_proofs: Vec::new(),
+            validity_proofs: Vec::new(),
+        }
+    }
+}

crates/proof/src/eigenda_provider.rs

@@ -100,27 +100,4 @@ impl<T: CommsClient + Sync + Send> EigenDABlobProvider for OracleEigenDAProvider
 
         Ok(blob.into())
     }
-
-    async fn get_element(&mut self, cert: &Bytes, element: &Bytes) -> Result<Bytes, Self::Error> {
-        self.oracle
-            .write(&ExtendedHintType::EigenDACommitment.encode_with(&[cert]))
-            .await
-            .map_err(OracleProviderError::Preimage)?;
-
-        let cert_point_key = Bytes::copy_from_slice(&[cert.to_vec(), element.to_vec()].concat());
-
-        self.oracle
-            .write(&ExtendedHintType::EigenDACommitment.encode_with(&[&cert_point_key]))
-            .await
-            .map_err(OracleProviderError::Preimage)?;
-        let data = self
-            .oracle
-            .get(PreimageKey::new(
-                *keccak256(cert_point_key),
-                PreimageKeyType::GlobalGeneric,
-            ))
-            .await
-            .map_err(OracleProviderError::Preimage)?;
-        Ok(data.into())
-    }
 }

crates/proof/src/lib.rs

@@ -5,3 +5,7 @@ pub mod hint;
 pub mod pipeline;
 
 pub mod eigenda_provider;
+
+pub mod preloaded_eigenda_provider;
+
+pub mod eigenda_blob_witness;