chore(proof-compressio): cleanup

Author: saitima

crates/proof-compression/Cargo.toml

@@ -13,18 +13,17 @@ exclude = ["/data"]
 
 [dependencies]
 circuit_definitions.workspace = true
-fflonk.workspace = true
+fflonk = {workspace = true, optional = true}
 shivini.workspace = true
-gpu-prover.workspace = true
+gpu-prover = { workspace = true, optional = true}
 serde = "1"
 serde_json = "1"
 bincode = "1.3"
 cfg-if = "1.0"
 byteorder = "1"
 
 [features]
-default = ["gpu"]
+default = ["gpu", "fflonk", "gpu-prover"]
 gpu = []
 cpu = []
-
-#TODO: define allocator
+allocator = ["fflonk/allocator", "gpu-prover/allocator"]

crates/proof-compression/scripts/download-ignition-transcripts.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+# Configuration: adjust these variables as needed
+BASE_URL="https://aztec-ignition.s3.eu-west-2.amazonaws.com/MAIN+IGNITION/sealed/transcript"  # Base URL before the index
+FILE_EXT=".dat"                              # File extension (if any)
+START_INDEX=0                                # Starting index
+END_INDEX=15                                 # Ending index
+
+# Loop over the desired range of indexes
+for ((i=START_INDEX; i<=END_INDEX; i++)); do
+  # Format the index as two digits (e.g., 01, 02, ..., 10)
+  FORMATTED_INDEX=$(printf "%02d" "$i")
+
+  # Construct the full URL for the current file using the formatted index
+  FILE_URL="${BASE_URL}${FORMATTED_INDEX}${FILE_EXT}"
+  
+  echo "Downloading ${FILE_URL} ..."
+  
+  # Download the file using wget
+  wget "$FILE_URL"
+  
+  # Check if the download succeeded; if not, optionally handle errors
+  if [[ $? -ne 0 ]]; then
+    echo "Failed to download ${FILE_URL}"
+    # Optionally break or continue based on your needs
+  fi
+done
+
+echo "Download complete."

…ates/proof-compression/setup-instance.sh …of-compression/scripts/setup-instance.shcrates/proof-compression/setup-instance.sh renamed to crates/proof-compression/scripts/setup-instance.sh crates/proof-compression/setup-instance.sh renamed to crates/proof-compression/scripts/setup-instance.sh

@@ -15,11 +15,10 @@ pub trait BlobStorage: Send + Sync {
 
     fn read_fflonk_vk(&self) -> Box<dyn Read>;
     fn read_fflonk_precomputation(&self) -> Box<dyn Read + Send + Sync>;
-    fn read_fflonk_crs(&self) -> Box<dyn Read>;
 
     fn read_plonk_vk(&self) -> Box<dyn Read>;
     fn read_plonk_precomputation(&self) -> Box<dyn Read + Send + Sync>;
-    fn read_plonk_crs(&self) -> Box<dyn Read>;
+    fn read_compact_raw_crs(&self) -> Box<dyn Read + Send + Sync>;
 }
 
 pub trait BlobStorageExt: BlobStorage {
@@ -33,14 +32,14 @@ pub trait BlobStorageExt: BlobStorage {
 
     fn write_fflonk_vk(&self) -> Box<dyn Write>;
     fn write_fflonk_precomputation(&self) -> Box<dyn Write>;
-    fn write_fflonk_crs(&self) -> Box<dyn Write>;
 
     fn write_plonk_vk(&self) -> Box<dyn Write>;
     fn write_plonk_precomputation(&self) -> Box<dyn Write>;
-    fn write_plonk_crs(&self) -> Box<dyn Write>;
+
+    fn write_compact_raw_crs(&self) -> Box<dyn Write>;
 }
 
-pub struct FileSystemBlobStorage;
+pub(crate) struct FileSystemBlobStorage;
 
 impl FileSystemBlobStorage {
     const DATA_DIR_PATH: &str = "./data";
@@ -163,24 +162,9 @@ impl BlobStorage for FileSystemBlobStorage {
         println!("Reading plonk vk at path {}", path);
         Self::open_file(&path)
     }
-
-    fn read_fflonk_crs(&self) -> Box<dyn Read> {
-        let path = format!(
-            "{}/{}_compact_crs.key.raw",
-            Self::DATA_DIR_PATH,
-            Self::FFLONK_PREFIX
-        );
-        println!("Reading fflonk CRS at path {}", path);
-        Self::open_file(&path)
-    }
-
-    fn read_plonk_crs(&self) -> Box<dyn Read> {
-        let path = format!(
-            "{}/{}_compact_crs.key.raw",
-            Self::DATA_DIR_PATH,
-            Self::PLONK_PREFIX
-        );
-        println!("Reading fflonk CRS at path {}", path);
+    fn read_compact_raw_crs(&self) -> Box<dyn Read + Send + Sync> {
+        let path = format!("{}/compact_raw_crs.key", Self::DATA_DIR_PATH,);
+        println!("Reading CRS at path {}", path);
         Self::open_file(&path)
     }
 }
@@ -279,36 +263,22 @@ impl BlobStorageExt for FileSystemBlobStorage {
         Self::create_file(&path)
     }
 
-    fn write_fflonk_crs(&self) -> Box<dyn Write> {
-        let path = format!(
-            "{}/{}_compact_crs.key.raw",
-            Self::DATA_DIR_PATH,
-            Self::PLONK_PREFIX
-        );
-        println!("Writeing fflonk CRS at path {}", path);
-        Self::create_file(&path)
-    }
-
-    fn write_plonk_crs(&self) -> Box<dyn Write> {
-        let path = format!(
-            "{}/{}_compact_crs.key.raw",
-            Self::DATA_DIR_PATH,
-            Self::PLONK_PREFIX
-        );
-        println!("Writeing plonk CRS at path {}", path);
+    fn write_compact_raw_crs(&self) -> Box<dyn Write> {
+        let path = format!("{}/compact_raw_crs.key", Self::DATA_DIR_PATH);
+        println!("Writeing compact raw CRS at path {}", path);
         Self::create_file(&path)
     }
 }
 
-pub struct AsyncHandler<T: Send + Sync + 'static> {
+pub(crate) struct AsyncHandler<T: Send + Sync + 'static> {
     receiver: std::thread::JoinHandle<std::sync::mpsc::Receiver<T>>,
 }
 
 impl<T> AsyncHandler<T>
 where
     T: Send + Sync + 'static,
 {
-    pub fn spawn<F>(f: F) -> Self
+    pub(crate) fn spawn<F>(f: F) -> Self
     where
         F: FnOnce() -> std::sync::mpsc::Receiver<T> + Send + Sync + 'static,
     {
@@ -317,7 +287,7 @@ where
         Self { receiver }
     }
 
-    pub fn wait(self) -> T {
+    pub(crate) fn wait(self) -> T {
         self.receiver.join().unwrap().recv().unwrap()
     }
 }

crates/proof-compression/src/blob_storage.rs

@@ -1,3 +1,8 @@
+use circuit_definitions::circuit_definitions::aux_layer::compression_modes::{
+    CompressionMode1, CompressionMode1ForWrapper, CompressionMode2, CompressionMode3,
+    CompressionMode4, CompressionMode5ForWrapper,
+};
+
 use super::*;
 
 pub enum SnarkWrapper {
@@ -9,6 +14,12 @@ pub enum SnarkWrapperProof {
     FFfonk(FflonkSnarkVerifierCircuitProof),
 }
 
+pub type SchedulerProof = franklin_crypto::boojum::cs::implementations::proof::Proof<
+    GoldilocksField,
+    circuit_definitions::circuit_definitions::recursion_layer::RecursiveProofsTreeHasher,
+    GoldilocksExt2,
+>;
+
 pub fn run_proof_chain<BS>(
     input_proof: SchedulerProof,
     snark_wrapper: SnarkWrapper,
@@ -29,7 +40,7 @@ where
     }
 }
 
-pub(crate) fn run_proof_chain_with_fflonk<BS>(
+pub fn run_proof_chain_with_fflonk<BS>(
     input_proof: SchedulerProof,
     blob_storage: &BS,
 ) -> FflonkSnarkVerifierCircuitProof
@@ -38,8 +49,10 @@ where
 {
     let context_manager = SimpleContextManager::new();
     let start = std::time::Instant::now();
-    let snark_context_config =
-        context_manager.initialize_snark_context_config::<FflonkSnarkWrapper>();
+    let compact_raw_crs =
+        <FflonkSnarkWrapper as SnarkWrapperStep>::load_compact_raw_crs(blob_storage);
+    let fflonk_precomputation = FflonkSnarkWrapper::get_precomputation(blob_storage);
+
     let next_proof =
         CompressionMode1::prove_compression_step(input_proof, blob_storage, &context_manager);
     let next_proof = CompressionMode2::prove_compression_step::<_, SimpleContextManager>(
@@ -67,7 +80,8 @@ where
         start.elapsed().as_secs()
     );
     let final_proof = FflonkSnarkWrapper::prove_snark_wrapper_step::<_, SimpleContextManager>(
-        snark_context_config,
+        compact_raw_crs,
+        fflonk_precomputation,
         next_proof,
         blob_storage,
         &context_manager,
@@ -79,13 +93,14 @@ where
     final_proof
 }
 
-pub(crate) fn precompute_proof_chain_with_fflonk<BS>(blob_storage: &BS)
+pub fn precompute_proof_chain_with_fflonk<BS>(blob_storage: &BS)
 where
     BS: BlobStorageExt,
 {
     let context_manager = SimpleContextManager::new();
-    let snark_context_config =
-        context_manager.initialize_snark_context_config::<FflonkSnarkWrapper>();
+    let compact_raw_crs =
+        <FflonkSnarkWrapper as SnarkWrapperStep>::load_compact_raw_crs(blob_storage);
+
     let start = std::time::Instant::now();
     CompressionMode1::precomputae_and_store_compression_circuits(blob_storage, &context_manager);
     CompressionMode2::precomputae_and_store_compression_circuits(blob_storage, &context_manager);
@@ -100,61 +115,68 @@ where
         start.elapsed().as_secs()
     );
     FflonkSnarkWrapper::precompute_and_store_snark_wrapper_circuit(
-        snark_context_config,
+        compact_raw_crs,
         blob_storage,
         &context_manager,
     );
     println!(
-        "Precomputation of entire chain took {}s",
+        "Precomputation of entire chain with fflonk took {}s",
         start.elapsed().as_secs()
     );
 }
 
-pub(crate) fn run_proof_chain_with_plonk<BS>(
+pub fn run_proof_chain_with_plonk<BS>(
     input_proof: SchedulerProof,
     blob_storage: &BS,
 ) -> PlonkSnarkVerifierCircuitProof
 where
     BS: BlobStorage,
 {
     let context_manager = SimpleContextManager::new();
-    let snark_context_config =
-        context_manager.initialize_snark_context_config::<PlonkSnarkWrapper>();
     let start = std::time::Instant::now();
+    let compact_raw_crs =
+        <PlonkSnarkWrapper as SnarkWrapperStep>::load_compact_raw_crs(blob_storage);
+    let plonk_precomputation = PlonkSnarkWrapper::get_precomputation(blob_storage);
+
     let next_proof = CompressionMode1ForWrapper::prove_compression_step(
         input_proof,
         blob_storage,
         &context_manager,
     );
 
     let final_proof = PlonkSnarkWrapper::prove_snark_wrapper_step(
-        snark_context_config,
+        compact_raw_crs,
+        plonk_precomputation,
         next_proof,
         blob_storage,
         &context_manager,
     );
     println!(
-        "Entire compression chain took {}s",
+        "Entire compression chain with plonk took {}s",
         start.elapsed().as_secs()
     );
     final_proof
 }
 
-pub(crate) fn precompute_proof_chain_with_plonk<BS>(blob_storage: &BS)
+pub fn precompute_proof_chain_with_plonk<BS>(blob_storage: &BS)
 where
     BS: BlobStorageExt,
 {
     let context_manager = SimpleContextManager::new();
-    let snark_context_config =
-        context_manager.initialize_snark_context_config::<PlonkSnarkWrapper>();
+    let start = std::time::Instant::now();
+    let compact_raw_crs =
+        <PlonkSnarkWrapper as SnarkWrapperStep>::load_compact_raw_crs(blob_storage);
     CompressionMode1ForWrapper::precomputae_and_store_compression_circuits(
         blob_storage,
         &context_manager,
     );
     PlonkSnarkWrapper::precompute_and_store_snark_wrapper_circuit(
-        snark_context_config,
+        compact_raw_crs,
         blob_storage,
         &context_manager,
     );
-    println!("All steps in this approach precomputed and saved into blob storage");
+    println!(
+        "Precomputation of entire chain with fflonk took {}s",
+        start.elapsed().as_secs()
+    );
 }