replaced assert! with anyhow::ensure!

Author: AlexOnTheStorm

crates/proof-compression/src/blob_storage.rs

@@ -305,7 +305,7 @@ impl FileSystemBlobStorage {
     ) -> anyhow::Result<
         VerificationKey<GoldilocksField, <CS as CompressionStep>::PreviousStepTreeHasher>,
     > {
-        assert!(CS::MODE >= 1);
+        anyhow::ensure!(CS::MODE >= 1);
         let path = if CS::MODE == 1 {
             format!("{}/{}_vk.json", Self::DATA_DIR_PATH, Self::SCHEDULER_PREFIX,)
         } else {

crates/proof-compression/src/proof_system/boojum.rs

@@ -151,7 +151,7 @@ where
         vk: &Self::VK,
     ) -> anyhow::Result<Self::Proof> {
         let domain_size = vk.fixed_parameters.domain_size as usize;
-        assert_eq!(finalization_hint.final_trace_len, domain_size);
+        anyhow::ensure!(finalization_hint.final_trace_len == domain_size);
         let cache_strategy = CacheStrategy {
             setup_polynomials: PolynomialsCacheStrategy::CacheMonomialsAndFirstCoset,
             trace_polynomials: PolynomialsCacheStrategy::CacheMonomialsAndFirstCoset,
@@ -210,7 +210,7 @@ where
             proof_config.merkle_tree_cap_size,
         );
         let domain_size = vk_params.domain_size as usize;
-        assert_eq!(finalization_hint.final_trace_len, domain_size);
+        anyhow::ensure!(finalization_hint.final_trace_len == domain_size);
         let (precomputation, vk) =
             shivini::cs::gpu_setup_and_vk_from_base_setup_vk_params_and_hints::<
                 CF::ThisLayerHasher,

crates/proof-compression/src/proof_system/fflonk.rs

@@ -103,13 +103,13 @@ impl SnarkWrapperProofSystem for FflonkSnarkWrapper {
         precomputation: &Self::Precomputation,
         finalization_hint: &Self::FinalizationHint,
     ) -> anyhow::Result<Self::Proof> {
-        assert!(proving_assembly.is_satisfied());
+        anyhow::ensure!(proving_assembly.is_satisfied());
         let raw_trace_len = proving_assembly.n();
-        assert!(finalization_hint.is_power_of_two());
+        anyhow::ensure!(finalization_hint.is_power_of_two());
         proving_assembly.finalize_to_size_log_2(finalization_hint.trailing_zeros() as usize);
         let domain_size = proving_assembly.n() + 1;
-        assert!(domain_size.is_power_of_two());
-        assert_eq!(domain_size, finalization_hint.clone());
+        anyhow::ensure!(domain_size.is_power_of_two());
+        anyhow::ensure!(domain_size == finalization_hint.clone());
         let precomputation = precomputation.into_inner_ref();
         let start = std::time::Instant::now();
         let proof = ::fflonk::create_proof::<_, _, _, RollingKeccakTranscript<_>, _>(

crates/proof-compression/src/proof_system/plonk.rs

@@ -78,7 +78,7 @@ impl PlonkSnarkWrapper {
         >,
         setup_data_cache: SnarkWrapperSetupData<Self>,
     ) -> anyhow::Result<<Self as ProofSystemDefinition>::Proof> {
-        assert!(Self::IS_FFLONK ^ Self::IS_PLONK);
+        anyhow::ensure!(Self::IS_FFLONK ^ Self::IS_PLONK);
         let input_vk = setup_data_cache.previous_vk;
         let mut ctx = Self::init_context(&setup_data_cache.crs)?.into_inner();
         let finalization_hint = setup_data_cache.finalization_hint;
@@ -88,12 +88,12 @@ impl PlonkSnarkWrapper {
         let vk = setup_data_cache.vk;
         let mut precomputation = setup_data_cache.precomputation.into_inner();
 
-        assert!(proving_assembly.is_satisfied());
-        assert!(finalization_hint.is_power_of_two());
+        anyhow::ensure!(proving_assembly.is_satisfied());
+        anyhow::ensure!(finalization_hint.is_power_of_two());
         proving_assembly.finalize_to_size_log_2(finalization_hint.trailing_zeros() as usize);
         let domain_size = proving_assembly.n() + 1;
-        assert!(domain_size.is_power_of_two());
-        assert_eq!(domain_size, finalization_hint.clone());
+        anyhow::ensure!(domain_size.is_power_of_two());
+        anyhow::ensure!(domain_size == finalization_hint.clone());
 
         let worker = bellman::worker::Worker::new();
         let start = std::time::Instant::now();
@@ -111,7 +111,7 @@ impl PlonkSnarkWrapper {
         println!("plonk proving takes {} s", start.elapsed().as_secs());
         ctx.free_all_slots();
 
-        assert!(<Self as ProofSystemDefinition>::verify(&proof, &vk));
+        anyhow::ensure!(<Self as ProofSystemDefinition>::verify(&proof, &vk));
 
         Ok(proof)
     }
@@ -130,13 +130,13 @@ impl PlonkSnarkWrapper {
         let circuit = Self::build_circuit(input_vk, None);
         let mut setup_assembly =
             <Self as SnarkWrapperProofSystemExt>::synthesize_for_setup(circuit);
-        assert!(setup_assembly.is_satisfied());
-        assert!(hardcoded_finalization_hint.is_power_of_two());
+        anyhow::ensure!(setup_assembly.is_satisfied());
+        anyhow::ensure!(hardcoded_finalization_hint.is_power_of_two());
         setup_assembly
             .finalize_to_size_log_2(hardcoded_finalization_hint.trailing_zeros() as usize);
         let domain_size = setup_assembly.n() + 1;
-        assert!(domain_size.is_power_of_two());
-        assert_eq!(domain_size, hardcoded_finalization_hint);
+        anyhow::ensure!(domain_size.is_power_of_two());
+        anyhow::ensure!(domain_size == hardcoded_finalization_hint);
         let mut ctx = Self::init_context(&crs)?.into_inner();
 
         let worker = bellman::worker::Worker::new();

crates/proof-compression/src/step/compression.rs

@@ -86,7 +86,7 @@ pub trait CompressionStep: CompressionProofSystem {
             &finalization_hint,
             &vk,
         )?;
-        assert!(<Self as ProofSystemDefinition>::verify(&proof, &vk));
+        anyhow::ensure!(<Self as ProofSystemDefinition>::verify(&proof, &vk));
 
         Ok(proof)
     }

crates/proof-compression/src/step/snark_wrapper.rs

@@ -32,7 +32,7 @@ pub trait SnarkWrapperStep: SnarkWrapperProofSystem {
     >;
     fn load_finalization_hint() -> anyhow::Result<<Self as ProofSystemDefinition>::FinalizationHint>
     {
-        assert!(Self::IS_FFLONK ^ Self::IS_PLONK);
+        anyhow::ensure!(Self::IS_FFLONK ^ Self::IS_PLONK);
         let hint = if Self::IS_PLONK {
             (1 << <PlonkProverDeviceMemoryManagerConfig as gpu_prover::ManagerConfigs>::FULL_SLOT_SIZE_LOG).to_string()
         } else {
@@ -75,7 +75,7 @@ pub trait SnarkWrapperStep: SnarkWrapperProofSystem {
         input_proof: Proof<GoldilocksField, Self::PreviousStepTreeHasher, GoldilocksExt2>,
         setup_data_cache: &SnarkWrapperSetupData<Self>,
     ) -> anyhow::Result<<Self as ProofSystemDefinition>::Proof> {
-        assert!(Self::IS_FFLONK ^ Self::IS_PLONK);
+        anyhow::ensure!(Self::IS_FFLONK ^ Self::IS_PLONK);
         let input_vk = &setup_data_cache.previous_vk;
         let crs = &setup_data_cache.crs;
         let ctx = Self::init_context(&crs)?;
@@ -92,7 +92,7 @@ pub trait SnarkWrapperStep: SnarkWrapperProofSystem {
             finalization_hint,
         )?;
 
-        assert!(<Self as ProofSystemDefinition>::verify(&proof, &vk));
+        anyhow::ensure!(<Self as ProofSystemDefinition>::verify(&proof, &vk));
 
         Ok(proof)
     }