feat: Loading setup for proving network

crates/proof-compression/Cargo.toml

@@ -21,6 +21,7 @@ serde_json = "1"
 bincode = "1.3"
 cfg-if = "1.0"
 byteorder = "1"
+anyhow = "1.0"
 
 [features]
 default = ["gpu", "fflonk", "gpu-prover"]

crates/proof-compression/src/chain.rs

@@ -1,11 +1,14 @@
+use std::sync::Arc;
+
+use ::fflonk::FflonkSnarkVerifierCircuitProof;
+use anyhow::Context;
 use circuit_definitions::circuit_definitions::aux_layer::{
     compression_modes::{
         CompressionMode1, CompressionMode1ForWrapper, CompressionMode2, CompressionMode3,
         CompressionMode4, CompressionMode5ForWrapper,
     },
     ZkSyncCompressionForWrapperProof, ZkSyncCompressionLayerProof,
 };
-use fflonk::FflonkSnarkVerifierCircuitProof;
 
 use super::*;
 
@@ -84,67 +87,51 @@ pub type SchedulerProof = franklin_crypto::boojum::cs::implementations::proof::P
     GoldilocksExt2,
 >;
 
-pub fn run_proof_chain<BS>(
+pub fn run_proof_chain(
     snark_wrapper: SnarkWrapper,
-    blob_storage: &BS,
+    setup_data_cache: Arc<dyn CompressorBlobStorage>,
     scheduler_proof: SchedulerProof,
-) -> SnarkWrapperProof
-where
-    BS: BlobStorage,
-{
+) -> SnarkWrapperProof {
     match snark_wrapper {
-        SnarkWrapper::Plonk => run_proof_chain_with_plonk(blob_storage, scheduler_proof),
-        SnarkWrapper::FFfonk => run_proof_chain_with_fflonk(blob_storage, scheduler_proof),
+        SnarkWrapper::Plonk => run_proof_chain_with_plonk(setup_data_cache, scheduler_proof),
+        SnarkWrapper::FFfonk => run_proof_chain_with_fflonk(setup_data_cache, scheduler_proof),
     }
 }
 
-pub fn run_proof_chain_with_fflonk<BS>(
-    blob_storage: &BS,
+pub fn run_proof_chain_with_fflonk(
+    setup_data_cache: Arc<dyn CompressorBlobStorage>,
     scheduler_proof: SchedulerProof,
-) -> SnarkWrapperProof
-where
-    BS: BlobStorage,
-{
-    let context_manager = SimpleContextManager::new();
+) -> SnarkWrapperProof {
     let start = std::time::Instant::now();
     <FflonkSnarkWrapper as SnarkWrapperStep>::run_pre_initialization_tasks();
-    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(scheduler_proof, blob_storage, &context_manager);
 
-    let next_proof = CompressionMode2::prove_compression_step::<_, SimpleContextManager>(
+    let next_proof = CompressionMode1::prove_compression_step(
+        scheduler_proof,
+        setup_data_cache.get_compression_mode1_setup_data(),
+    );
+    let next_proof = CompressionMode2::prove_compression_step(
         next_proof,
-        blob_storage,
-        &context_manager,
+        setup_data_cache.get_compression_mode2_setup_data(),
     );
-    let next_proof = CompressionMode3::prove_compression_step::<_, SimpleContextManager>(
+    let next_proof = CompressionMode3::prove_compression_step(
         next_proof,
-        blob_storage,
-        &context_manager,
+        setup_data_cache.get_compression_mode3_setup_data(),
     );
-
-    let next_proof = CompressionMode4::prove_compression_step::<_, SimpleContextManager>(
+    let next_proof = CompressionMode4::prove_compression_step(
         next_proof,
-        blob_storage,
-        &context_manager,
+        setup_data_cache.get_compression_mode4_setup_data(),
     );
-    let next_proof = CompressionMode5ForWrapper::prove_compression_step::<_, SimpleContextManager>(
+    let next_proof = CompressionMode5ForWrapper::prove_compression_step(
         next_proof,
-        blob_storage,
-        &context_manager,
+        setup_data_cache.get_compression_mode5_for_wrapper_setup_data(),
     );
     println!(
         "Proving entire compression chain took {}s",
         start.elapsed().as_secs()
     );
-    let final_proof = FflonkSnarkWrapper::prove_snark_wrapper_step::<_, SimpleContextManager>(
-        compact_raw_crs,
-        fflonk_precomputation,
+    let final_proof = FflonkSnarkWrapper::prove_snark_wrapper_step(
         next_proof,
-        blob_storage,
-        &context_manager,
+        setup_data_cache.get_fflonk_snark_wrapper_setup_data(),
     );
     println!(
         "Proving entire chain with snark wrapper took {}s",
@@ -153,64 +140,96 @@ where
     SnarkWrapperProof::FFfonk(final_proof)
 }
 
-pub fn precompute_proof_chain_with_fflonk<BS>(blob_storage: &BS)
-where
-    BS: BlobStorageExt,
-{
-    let context_manager = SimpleContextManager::new();
+pub fn precompute_proof_chain_with_fflonk(setup_data_cache: Arc<dyn CompressorBlobStorageExt>) {
     <FflonkSnarkWrapper as SnarkWrapperStep>::run_pre_initialization_tasks();
-    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);
-    CompressionMode3::precomputae_and_store_compression_circuits(blob_storage, &context_manager);
-    CompressionMode4::precomputae_and_store_compression_circuits(blob_storage, &context_manager);
-    CompressionMode5ForWrapper::precomputae_and_store_compression_circuits(
-        blob_storage,
-        &context_manager,
+
+    let (precomputation, vk, finalization_hint) = CompressionMode1::precompute_compression_circuits(
+        setup_data_cache
+            .get_compression_mode1_previous_vk()
+            .unwrap(),
+    );
+    setup_data_cache
+        .set_compression_mode1_setup_data(&precomputation, &vk, &finalization_hint)
+        .context("Failed to set compression mode 1 setup data")
+        .unwrap();
+
+    let (precomputation, vk, finalization_hint) = CompressionMode2::precompute_compression_circuits(
+        setup_data_cache
+            .get_compression_mode2_previous_vk()
+            .unwrap(),
+    );
+    setup_data_cache
+        .set_compression_mode2_setup_data(&precomputation, &vk, &finalization_hint)
+        .context("Failed to set compression mode 2 setup data")
+        .unwrap();
+
+    let (precomputation, vk, finalization_hint) = CompressionMode3::precompute_compression_circuits(
+        setup_data_cache
+            .get_compression_mode3_previous_vk()
+            .unwrap(),
+    );
+    setup_data_cache
+        .set_compression_mode3_setup_data(&precomputation, &vk, &finalization_hint)
+        .context("Failed to set compression mode 3 setup data")
+        .unwrap();
+
+    let (precomputation, vk, finalization_hint) = CompressionMode4::precompute_compression_circuits(
+        setup_data_cache
+            .get_compression_mode4_previous_vk()
+            .unwrap(),
     );
+    setup_data_cache
+        .set_compression_mode4_setup_data(&precomputation, &vk, &finalization_hint)
+        .context("Failed to set compression mode 4 setup data")
+        .unwrap();
+
+    let (precomputation, vk, finalization_hint) =
+        CompressionMode5ForWrapper::precompute_compression_circuits(
+            setup_data_cache
+                .get_compression_mode5_for_wrapper_previous_vk()
+                .unwrap(),
+        );
+    setup_data_cache
+        .set_compression_mode5_for_wrapper_setup_data(&precomputation, &vk, &finalization_hint)
+        .context("Failed to set compression mode 5 for wrapper setup data")
+        .unwrap();
+
     println!(
         "Precomputation of compression chain took {}s",
         start.elapsed().as_secs()
     );
-    FflonkSnarkWrapper::precompute_and_store_snark_wrapper_circuit(
-        compact_raw_crs,
-        blob_storage,
-        &context_manager,
-    );
+
+    let (previous_vk, finalization_hint, ctx) = setup_data_cache
+        .get_fflonk_snark_wrapper_previous_vk_finalization_hint_and_ctx()
+        .unwrap();
+    let (precomputation, vk) =
+        FflonkSnarkWrapper::precompute_snark_wrapper_circuit(previous_vk, finalization_hint, ctx);
+    setup_data_cache
+        .set_fflonk_snark_wrapper_setup_data(&precomputation, &vk)
+        .context("Failed to set Fflonk snark wrapper setup data")
+        .unwrap();
     println!(
         "Precomputation of entire chain with fflonk took {}s",
         start.elapsed().as_secs()
     );
 }
 
-pub fn run_proof_chain_with_plonk<BS>(
-    blob_storage: &BS,
+pub fn run_proof_chain_with_plonk(
+    setup_data_cache: Arc<dyn CompressorBlobStorage>,
     scheduler_proof: SchedulerProof,
-) -> SnarkWrapperProof
-where
-    BS: BlobStorage,
-{
-    let context_manager = SimpleContextManager::new();
+) -> SnarkWrapperProof {
     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(
         scheduler_proof,
-        blob_storage,
-        &context_manager,
+        setup_data_cache.get_compression_mode1_for_wrapper_setup_data(),
     );
 
-    let final_proof = PlonkSnarkWrapper::prove_snark_wrapper_step(
-        compact_raw_crs,
-        plonk_precomputation,
+    let final_proof = PlonkSnarkWrapper::prove_plonk_snark_wrapper_step(
         next_proof,
-        blob_storage,
-        &context_manager,
+        setup_data_cache.get_plonk_snark_wrapper_setup_data(),
     );
     println!(
         "Entire compression chain with plonk took {}s",
@@ -219,25 +238,38 @@ where
     SnarkWrapperProof::Plonk(final_proof)
 }
 
-pub fn precompute_proof_chain_with_plonk<BS>(blob_storage: &BS)
-where
-    BS: BlobStorageExt,
-{
-    let context_manager = SimpleContextManager::new();
+pub fn precompute_proof_chain_with_plonk(setup_data_cache: Arc<dyn CompressorBlobStorageExt>) {
     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,
+
+    let (precomputation, vk, finalization_hint) =
+        CompressionMode1ForWrapper::precompute_compression_circuits(
+            setup_data_cache
+                .get_compression_mode1_for_wrapper_previous_vk()
+                .unwrap(),
+        );
+    setup_data_cache
+        .set_compression_mode1_for_wrapper_setup_data(&precomputation, &vk, &finalization_hint)
+        .context("Failed to set compression mode 1 for wrapper setup data")
+        .unwrap();
+    println!(
+        "Precomputation of compression chain took {}s",
+        start.elapsed().as_secs()
     );
-    PlonkSnarkWrapper::precompute_and_store_snark_wrapper_circuit(
-        compact_raw_crs,
-        blob_storage,
-        &context_manager,
+    let (previous_vk, finalization_hint, ctx) = setup_data_cache
+        .get_plonk_snark_wrapper_previous_vk_finalization_hint_and_ctx()
+        .unwrap();
+    let (precomputation, vk) = PlonkSnarkWrapper::precompute_plonk_snark_wrapper_circuit(
+        previous_vk,
+        finalization_hint,
+        ctx,
     );
+    setup_data_cache
+        .set_plonk_snark_wrapper_setup_data(&precomputation, &vk)
+        .context("Failed to set Plonk snark wrapper setup data")
+        .unwrap();
+
     println!(
-        "Precomputation of entire chain with fflonk took {}s",
+        "Precomputation of entire chain with plonk took {}s",
         start.elapsed().as_secs()
     );
 }