feat: handle versioning and validium tasks

Author: roynalnaruto

Cargo.lock

@@ -17,9 +17,9 @@ repository = "https://github.com/scroll-tech/scroll"
 version = "4.5.47"
 
 [workspace.dependencies]
-scroll-zkvm-prover = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "5c361ad" }
-scroll-zkvm-verifier = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "5c361ad" }
-scroll-zkvm-types = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "5c361ad" }
+scroll-zkvm-prover = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "aa935df" }
+scroll-zkvm-verifier = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "aa935df" }
+scroll-zkvm-types = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "aa935df" }
 
 sbv-primitives = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "master", features = ["scroll", "rkyv"] }
 sbv-utils = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "master" }

Cargo.toml

@@ -13,6 +13,7 @@ use tasks::chunk_interpreter::{ChunkInterpreter, TryFromWithInterpreter};
 
 /// global features: use legacy encoding for witness
 static mut LEGACY_WITNESS_ENCODING: bool = false;
+
 pub(crate) fn witness_use_legacy_mode() -> bool {
     unsafe { LEGACY_WITNESS_ENCODING }
 }

crates/libzkp/src/lib.rs

@@ -1,18 +1,20 @@
-use crate::{proofs::ChunkProof, VALIDIUM_VERSION};
 use c_kzg::Bytes48;
 use eyre::Result;
 use sbv_primitives::{B256, U256};
 use scroll_zkvm_types::{
     batch::{
         build_point_eval_witness, BatchHeader, BatchHeaderV6, BatchHeaderV7, BatchHeaderV8,
-        BatchInfo, BatchWitness, Envelope, EnvelopeV6, EnvelopeV7, EnvelopeV8, LegacyBatchWitness,
-        ReferenceHeader, N_BLOB_BYTES,
+        BatchHeaderValidium, BatchInfo, BatchWitness, Envelope, EnvelopeV6, EnvelopeV7, EnvelopeV8,
+        LegacyBatchWitness, ReferenceHeader, N_BLOB_BYTES,
     },
     public_inputs::{ForkName, Version},
     task::ProvingTask,
     utils::{to_rkyv_bytes, RancorError},
+    version::{Domain, STFVersion},
 };
 
+use crate::proofs::ChunkProof;
+
 mod utils;
 use utils::{base64, point_eval};
 
@@ -25,13 +27,15 @@ use utils::{base64, point_eval};
 pub enum BatchHeaderV {
     V6(BatchHeaderV6),
     V7_8(BatchHeaderV7),
+    Validium(BatchHeaderValidium),
 }
 
 impl BatchHeaderV {
     pub fn batch_hash(&self) -> B256 {
         match self {
             BatchHeaderV::V6(h) => h.batch_hash(),
             BatchHeaderV::V7_8(h) => h.batch_hash(),
+            BatchHeaderV::Validium(h) => h.batch_hash(),
         }
     }
 
@@ -55,12 +59,21 @@ impl BatchHeaderV {
             _ => panic!("try to pick other header type"),
         }
     }
+
+    pub fn must_validium_header(&self) -> &BatchHeaderValidium {
+        match self {
+            BatchHeaderV::Validium(h) => h,
+            _ => panic!("try to pick other header type"),
+        }
+    }
 }
 
 /// Defines a proving task for batch proof generation, the format
 /// is compatible with both pre-euclidv2 and euclidv2
 #[derive(Clone, serde::Deserialize, serde::Serialize)]
 pub struct BatchProvingTask {
+    /// The version of the chunks in the batch, as per [`Version`].
+    pub version: Version,
     /// Chunk proofs for the contiguous list of chunks within the batch.
     pub chunk_proofs: Vec<ChunkProof>,
     /// The [`BatchHeaderV6/V7`], as computed on-chain for this batch.
@@ -93,7 +106,7 @@ impl TryFrom<BatchProvingTask> for ProvingTask {
 
         Ok(ProvingTask {
             identifier: value.batch_header.batch_hash().to_string(),
-            fork_name: value.fork_name,
+            fork_name: value.version.fork.to_string(),
             aggregated_proofs: value
                 .chunk_proofs
                 .into_iter()
@@ -107,80 +120,105 @@ impl TryFrom<BatchProvingTask> for ProvingTask {
 
 impl BatchProvingTask {
     fn build_guest_input(&self) -> BatchWitness {
-        let fork_name = self.fork_name.to_lowercase().as_str().into();
-
-        // sanity check: calculate point eval needed and compare with task input
-        let (kzg_commitment, kzg_proof, challenge_digest) = {
-            let blob = point_eval::to_blob(&self.blob_bytes);
-            let commitment = point_eval::blob_to_kzg_commitment(&blob);
-            let versioned_hash = point_eval::get_versioned_hash(&commitment);
-            let challenge_digest = match &self.batch_header {
-                BatchHeaderV::V6(_) => {
-                    assert_eq!(
-                        fork_name,
-                        ForkName::EuclidV1,
-                        "hardfork mismatch for da-codec@v6 header: found={fork_name:?}, expected={:?}",
-                        ForkName::EuclidV1,
-                    );
-                    EnvelopeV6::from_slice(self.blob_bytes.as_slice())
-                        .challenge_digest(versioned_hash)
-                }
-                BatchHeaderV::V7_8(_) => {
-                    let padded_blob_bytes = {
-                        let mut padded_blob_bytes = self.blob_bytes.to_vec();
-                        padded_blob_bytes.resize(N_BLOB_BYTES, 0);
-                        padded_blob_bytes
-                    };
-
-                    match fork_name {
-                        ForkName::EuclidV2 => {
-                            <EnvelopeV7 as Envelope>::from_slice(padded_blob_bytes.as_slice())
-                                .challenge_digest(versioned_hash)
-                        }
-                        ForkName::Feynman => {
-                            <EnvelopeV8 as Envelope>::from_slice(padded_blob_bytes.as_slice())
-                                .challenge_digest(versioned_hash)
+        let point_eval_witness = if !self.version.is_validium() {
+            // sanity check: calculate point eval needed and compare with task input
+            let (kzg_commitment, kzg_proof, challenge_digest) = {
+                let blob = point_eval::to_blob(&self.blob_bytes);
+                let commitment = point_eval::blob_to_kzg_commitment(&blob);
+                let versioned_hash = point_eval::get_versioned_hash(&commitment);
+                let challenge_digest = match &self.batch_header {
+                    BatchHeaderV::V6(_) => {
+                        assert_eq!(
+                            self.version.fork,
+                            ForkName::EuclidV1,
+                            "hardfork mismatch for da-codec@v6 header: found={:?}, expected={:?}",
+                            self.version.fork,
+                            ForkName::EuclidV1,
+                        );
+                        EnvelopeV6::from_slice(self.blob_bytes.as_slice())
+                            .challenge_digest(versioned_hash)
+                    }
+                    BatchHeaderV::V7_8(_) => {
+                        let padded_blob_bytes = {
+                            let mut padded_blob_bytes = self.blob_bytes.to_vec();
+                            padded_blob_bytes.resize(N_BLOB_BYTES, 0);
+                            padded_blob_bytes
+                        };
+
+                        match self.version.fork {
+                            ForkName::EuclidV2 => {
+                                <EnvelopeV7 as Envelope>::from_slice(padded_blob_bytes.as_slice())
+                                    .challenge_digest(versioned_hash)
+                            }
+                            ForkName::Feynman => {
+                                <EnvelopeV8 as Envelope>::from_slice(padded_blob_bytes.as_slice())
+                                    .challenge_digest(versioned_hash)
+                            }
+                            fork_name => unreachable!(
+                                "hardfork mismatch for da-codec@v7 header: found={}, expected={:?}",
+                                fork_name,
+                                [ForkName::EuclidV2, ForkName::Feynman],
+                            ),
                         }
-                        f => unreachable!(
-                            "hardfork mismatch for da-codec@v7 header: found={}, expected={:?}",
-                            f,
-                            [ForkName::EuclidV2, ForkName::Feynman],
-                        ),
                     }
-                }
-            };
+                    BatchHeaderV::Validium(_) => unreachable!("version!=validium"),
+                };
 
-            let (proof, _) = point_eval::get_kzg_proof(&blob, challenge_digest);
+                let (proof, _) = point_eval::get_kzg_proof(&blob, challenge_digest);
 
-            (commitment.to_bytes(), proof.to_bytes(), challenge_digest)
-        };
+                (commitment.to_bytes(), proof.to_bytes(), challenge_digest)
+            };
 
-        if let Some(k) = self.kzg_commitment {
-            assert_eq!(k, kzg_commitment);
-        }
+            if let Some(k) = self.kzg_commitment {
+                assert_eq!(k, kzg_commitment);
+            }
 
-        if let Some(c) = self.challenge_digest {
-            assert_eq!(c, U256::from_be_bytes(challenge_digest.0));
-        }
+            if let Some(c) = self.challenge_digest {
+                assert_eq!(c, U256::from_be_bytes(challenge_digest.0));
+            }
 
-        if let Some(p) = self.kzg_proof {
-            assert_eq!(p, kzg_proof);
-        }
+            if let Some(p) = self.kzg_proof {
+                assert_eq!(p, kzg_proof);
+            }
 
-        let point_eval_witness = Some(build_point_eval_witness(
-            kzg_commitment.into_inner(),
-            kzg_proof.into_inner(),
-        ));
+            Some(build_point_eval_witness(
+                kzg_commitment.into_inner(),
+                kzg_proof.into_inner(),
+            ))
+        } else {
+            assert!(self.kzg_proof.is_none(), "domain=validium has no blob-da");
+            assert!(
+                self.kzg_commitment.is_none(),
+                "domain=validium has no blob-da"
+            );
+            assert!(
+                self.challenge_digest.is_none(),
+                "domain=validium has no blob-da"
+            );
+            None
+        };
 
-        let reference_header = match fork_name {
-            ForkName::EuclidV1 => ReferenceHeader::V6(*self.batch_header.must_v6_header()),
-            ForkName::EuclidV2 => ReferenceHeader::V7(*self.batch_header.must_v7_header()),
-            ForkName::Feynman => ReferenceHeader::V8(*self.batch_header.must_v8_header()),
+        let reference_header = match (self.version.domain, self.version.stf_version) {
+            (Domain::Scroll, STFVersion::V6) => {
+                ReferenceHeader::V6(*self.batch_header.must_v6_header())
+            }
+            (Domain::Scroll, STFVersion::V7) => {
+                ReferenceHeader::V7(*self.batch_header.must_v7_header())
+            }
+            (Domain::Scroll, STFVersion::V8) => {
+                ReferenceHeader::V8(*self.batch_header.must_v8_header())
+            }
+            (Domain::Validium, STFVersion::V1) => {
+                ReferenceHeader::Validium(*self.batch_header.must_validium_header())
+            }
+            (domain, stf_version) => {
+                unreachable!("unsupported domain={domain:?},stf-version={stf_version:?}")
+            }
         };
 
         BatchWitness {
-            version: VALIDIUM_VERSION,
-            fork_name,
+            version: self.version.as_version_byte(),
+            fork_name: self.version.fork,
             chunk_proofs: self.chunk_proofs.iter().map(|proof| proof.into()).collect(),
             chunk_infos: self
                 .chunk_proofs
@@ -194,15 +232,12 @@ impl BatchProvingTask {
     }
 
     pub fn precheck_and_build_metadata(&self) -> Result<BatchInfo> {
-        let fork_name = ForkName::from(self.fork_name.as_str());
         // for every aggregation task, there are two steps needed to build the metadata:
         // 1. generate data for metadata from the witness
         // 2. validate every adjacent proof pair
         let witness = self.build_guest_input();
         let metadata = BatchInfo::from(&witness);
-
-        // FIXME
-        super::check_aggregation_proofs(self.chunk_proofs.as_slice(), Version::validium_v1())?;
+        super::check_aggregation_proofs(self.chunk_proofs.as_slice(), self.version)?;
 
         Ok(metadata)
     }

crates/libzkp/src/tasks/batch.rs

@@ -1,17 +1,21 @@
-use crate::{proofs::BatchProof, VALIDIUM_VERSION};
 use eyre::Result;
 use scroll_zkvm_types::{
     bundle::{BundleInfo, BundleWitness, LegacyBundleWitness},
-    public_inputs::{ForkName, Version},
+    public_inputs::Version,
     task::ProvingTask,
     utils::{to_rkyv_bytes, RancorError},
 };
 
+use crate::proofs::BatchProof;
+
 /// Message indicating a sanity check failure.
 const BUNDLE_SANITY_MSG: &str = "bundle must have at least one batch";
 
 #[derive(Clone, serde::Deserialize, serde::Serialize)]
 pub struct BundleProvingTask {
+    /// The version of batches in the bundle.
+    pub version: Version,
+    /// The STARK proofs of each batch in the bundle.
     pub batch_proofs: Vec<BatchProof>,
     /// for sanity check
     pub bundle_info: Option<BundleInfo>,
@@ -41,26 +45,24 @@ impl BundleProvingTask {
 
     fn build_guest_input(&self) -> BundleWitness {
         BundleWitness {
-            version: VALIDIUM_VERSION,
+            version: self.version.as_version_byte(),
             batch_proofs: self.batch_proofs.iter().map(|proof| proof.into()).collect(),
             batch_infos: self
                 .batch_proofs
                 .iter()
                 .map(|wrapped_proof| wrapped_proof.metadata.batch_info.clone())
                 .collect(),
-            fork_name: self.fork_name.to_lowercase().as_str().into(),
+            fork_name: self.version.fork,
         }
     }
 
     pub fn precheck_and_build_metadata(&self) -> Result<BundleInfo> {
-        let fork_name = ForkName::from(self.fork_name.as_str());
         // for every aggregation task, there are two steps needed to build the metadata:
         // 1. generate data for metadata from the witness
         // 2. validate every adjacent proof pair
         let witness = self.build_guest_input();
         let metadata = BundleInfo::from(&witness);
-
-        super::check_aggregation_proofs(self.batch_proofs.as_slice(), Version::validium_v1())?;
+        super::check_aggregation_proofs(self.batch_proofs.as_slice(), self.version)?;
 
         Ok(metadata)
     }