fix: use ensure!() instead of assert!() for storage-proofs

Author: vmx

fil-proofs-tooling/src/bin/benchy/stacked.rs

@@ -497,7 +497,7 @@ pub struct RunOpts {
 }
 
 pub fn run(opts: RunOpts) -> anyhow::Result<()> {
-    let config = StackedConfig::new(opts.layers, opts.window_challenges, opts.wrapper_challenges);
+    let config = StackedConfig::new(opts.layers, opts.window_challenges, opts.wrapper_challenges)?;
 
     let params = Params {
         config,

filecoin-proofs/examples/stacked.rs

@@ -507,7 +507,8 @@ fn main() {
     let circuit = matches.is_present("circuit");
     let extract = matches.is_present("extract");
 
-    let config = StackedConfig::new(layers, window_challenge_count, wrapper_challenge_count);
+    let config =
+        StackedConfig::new(layers, window_challenge_count, wrapper_challenge_count).unwrap();
 
     info!("hasher: {}", hasher);
     match hasher.as_ref() {

filecoin-proofs/src/parameters.rs

@@ -57,10 +57,10 @@ pub fn setup_params(
     sector_bytes: PaddedBytesAmount,
     partitions: usize,
 ) -> Result<stacked::SetupParams> {
-    let window_challenges = select_challenges(partitions, POREP_WINDOW_MINIMUM_CHALLENGES, LAYERS);
+    let window_challenges = select_challenges(partitions, POREP_WINDOW_MINIMUM_CHALLENGES, LAYERS)?;
     let wrapper_challenges =
-        select_challenges(partitions, POREP_WRAPPER_MINIMUM_CHALLENGES, LAYERS);
-    let window_size_nodes = window_size_nodes_for_sector_bytes(sector_bytes).unwrap();
+        select_challenges(partitions, POREP_WRAPPER_MINIMUM_CHALLENGES, LAYERS)?;
+    let window_size_nodes = window_size_nodes_for_sector_bytes(sector_bytes)?;
     let sector_bytes = usize::from(sector_bytes);
 
     let config = StackedConfig {
@@ -96,14 +96,14 @@ fn select_challenges(
     partitions: usize,
     minimum_total_challenges: usize,
     layers: usize,
-) -> LayerChallenges {
+) -> Result<LayerChallenges> {
     let mut count = 1;
-    let mut guess = LayerChallenges::new(layers, count);
+    let mut guess = LayerChallenges::new(layers, count)?;
     while partitions * guess.challenges_count_all() < minimum_total_challenges {
         count += 1;
-        guess = LayerChallenges::new(layers, count);
+        guess = LayerChallenges::new(layers, count)?;
     }
-    guess
+    Ok(guess)
 }
 
 #[cfg(test)]
@@ -114,7 +114,11 @@ mod tests {
 
     #[test]
     fn partition_layer_challenges_test() {
-        let f = |partitions| select_challenges(partitions, 12, LAYERS).challenges_count_all();
+        let f = |partitions| {
+            select_challenges(partitions, 12, LAYERS)
+                .unwrap()
+                .challenges_count_all()
+        };
         // Update to ensure all supported PoRepProofPartitions options are represented here.
         assert_eq!(6, f(usize::from(PoRepProofPartitions(2))));
 

filecoin-proofs/src/pieces.rs

@@ -646,7 +646,7 @@ mod tests {
             BASE_DEGREE,
             EXP_DEGREE,
             new_seed(),
-        );
+        )?;
 
         let mut staged_sector = Vec::with_capacity(u64::from(sector_size) as usize);
         let mut staged_sector_io = std::io::Cursor::new(&mut staged_sector);

storage-proofs/benches/drgraph.rs

@@ -10,7 +10,7 @@ fn drgraph(c: &mut Criterion) {
         .iter()
         .map(|n| {
             (
-                BucketGraph::<PedersenHasher>::new(*n, BASE_DEGREE, 0, new_seed()),
+                BucketGraph::<PedersenHasher>::new(*n, BASE_DEGREE, 0, new_seed()).unwrap(),
                 2,
             )
         })
@@ -22,7 +22,7 @@ fn drgraph(c: &mut Criterion) {
             |b, (graph, i)| {
                 b.iter(|| {
                     let mut parents = vec![0; 6];
-                    black_box(graph.parents(*i, &mut parents));
+                    black_box(graph.parents(*i, &mut parents).unwrap());
                 })
             },
             params,

storage-proofs/benches/encode.rs

@@ -29,7 +29,7 @@ fn pregenerate_data<H: Hasher>(degree: usize) -> Pregenerated<H> {
     let parents: Vec<u32> = (0..degree as u32).map(|pos| pos).collect();
     let replica_id: H::Domain = H::Domain::random(&mut rng);
 
-    let graph = StackedBucketGraph::<H>::new_stacked(degree + 1, degree, 0, new_seed());
+    let graph = StackedBucketGraph::<H>::new_stacked(degree + 1, degree, 0, new_seed()).unwrap();
 
     Pregenerated {
         data,

storage-proofs/benches/merkle.rs

@@ -26,7 +26,8 @@ fn merkle_benchmark(c: &mut Criterion) {
                     BASE_DEGREE,
                     EXP_DEGREE,
                     new_seed(),
-                );
+                )
+                .unwrap();
 
                 b.iter(|| black_box(graph.merkle_tree(&data).unwrap()))
             },
@@ -40,7 +41,8 @@ fn merkle_benchmark(c: &mut Criterion) {
                 BASE_DEGREE,
                 EXP_DEGREE,
                 new_seed(),
-            );
+            )
+            .unwrap();
 
             b.iter(|| black_box(graph.merkle_tree(&data).unwrap()))
         })

storage-proofs/benches/parents.rs

@@ -41,12 +41,12 @@ fn stop_profile() {}
 
 fn pregenerate_graph<H: Hasher>(size: usize) -> StackedBucketGraph<H> {
     let seed = [1u8; 28];
-    StackedBucketGraph::<H>::new_stacked(size, BASE_DEGREE, EXP_DEGREE, seed)
+    StackedBucketGraph::<H>::new_stacked(size, BASE_DEGREE, EXP_DEGREE, seed).unwrap()
 }
 
 fn parents_loop<H: Hasher, G: Graph<H>>(graph: &G, parents: &mut [u32]) {
     (0..graph.size())
-        .map(|node| graph.parents(node, parents))
+        .map(|node| graph.parents(node, parents).unwrap())
         .collect()
 }
 

storage-proofs/src/circuit/drgporep.rs

@@ -15,6 +15,7 @@ use crate::compound_proof::{CircuitComponent, CompoundProof};
 use crate::crypto::pedersen::JJ_PARAMS;
 use crate::drgporep::DrgPoRep;
 use crate::drgraph::Graph;
+use crate::error::Result;
 use crate::fr32::fr_into_bytes;
 use crate::hasher::Hasher;
 use crate::merklepor;
@@ -148,11 +149,14 @@ where
         // We can ignore k because challenges are generated by caller and included
         // in PublicInputs.
         _k: Option<usize>,
-    ) -> Vec<Fr> {
+    ) -> Result<Vec<Fr>> {
         let replica_id = pub_in.replica_id.expect("missing replica id");
         let challenges = &pub_in.challenges;
 
-        assert_eq!(pub_in.tau.is_none(), pub_params.private);
+        ensure!(
+            pub_in.tau.is_none() == pub_params.private,
+            "Public input parameter tau must be unset"
+        );
 
         let (comm_r, comm_d) = match pub_in.tau {
             None => (None, None),
@@ -172,7 +176,7 @@ where
         let mut parents = vec![0; pub_params.graph.degree()];
         for challenge in challenges {
             let mut por_nodes = vec![*challenge as u32];
-            pub_params.graph.parents(*challenge, &mut parents);
+            pub_params.graph.parents(*challenge, &mut parents)?;
             por_nodes.extend_from_slice(&parents);
 
             for node in por_nodes {
@@ -184,7 +188,7 @@ where
                     &por_pub_inputs,
                     &por_pub_params,
                     None,
-                );
+                )?;
 
                 input.extend(por_inputs);
             }
@@ -195,24 +199,30 @@ where
             };
 
             let por_inputs =
-                PoRCompound::<H>::generate_public_inputs(&por_pub_inputs, &por_pub_params, None);
+                PoRCompound::<H>::generate_public_inputs(&por_pub_inputs, &por_pub_params, None)?;
             input.extend(por_inputs);
         }
-        input
+        Ok(input)
     }
 
     fn circuit(
         public_inputs: &<DrgPoRep<'a, H, G> as ProofScheme<'a>>::PublicInputs,
         component_private_inputs: <DrgPoRepCircuit<'a, H> as CircuitComponent>::ComponentPrivateInputs,
         proof: &<DrgPoRep<'a, H, G> as ProofScheme<'a>>::Proof,
         public_params: &<DrgPoRep<'a, H, G> as ProofScheme<'a>>::PublicParams,
-    ) -> DrgPoRepCircuit<'a, H> {
+    ) -> Result<DrgPoRepCircuit<'a, H>> {
         let challenges = public_params.challenges_count;
         let len = proof.nodes.len();
 
-        assert!(len <= challenges, "too many challenges");
-        assert_eq!(proof.replica_parents.len(), len);
-        assert_eq!(proof.replica_nodes.len(), len);
+        ensure!(len <= challenges, "too many challenges");
+        ensure!(
+            proof.replica_parents.len() == len,
+            "Number of replica parents must match"
+        );
+        ensure!(
+            proof.replica_nodes.len() == len,
+            "Number of replica nodes must match"
+        );
 
         let replica_nodes: Vec<_> = proof
             .replica_nodes
@@ -277,13 +287,12 @@ where
             .map(|node| node.proof.as_options())
             .collect();
 
-        assert_eq!(
-            public_inputs.tau.is_none(),
-            public_params.private,
+        ensure!(
+            public_inputs.tau.is_none() == public_params.private,
             "inconsistent private state"
         );
 
-        DrgPoRepCircuit {
+        Ok(DrgPoRepCircuit {
             params: &*JJ_PARAMS,
             replica_nodes,
             replica_nodes_paths,
@@ -296,7 +305,7 @@ where
             replica_id: replica_id.map(Into::into),
             private: public_params.private,
             _h: Default::default(),
-        }
+        })
     }
 
     fn blank_circuit(
@@ -666,7 +675,8 @@ mod tests {
                 &pub_inputs,
                 &pp,
                 None,
-            );
+            )
+            .unwrap();
         let expected_inputs = cs.get_inputs();
 
         for ((input, label), generated_input) in
@@ -812,7 +822,8 @@ mod tests {
                 &public_params,
                 &public_inputs,
                 &private_inputs,
-            );
+            )
+            .unwrap();
 
             let mut cs = TestConstraintSystem::new();
 

storage-proofs/src/circuit/election_post.rs

@@ -18,6 +18,7 @@ use crate::compound_proof::{CircuitComponent, CompoundProof};
 use crate::crypto::pedersen::JJ_PARAMS;
 use crate::drgraph;
 use crate::election_post::{self, ElectionPoSt};
+use crate::error::Result;
 use crate::fr32::fr_into_bytes;
 use crate::hasher::Hasher;
 use crate::merklepor;
@@ -75,7 +76,7 @@ where
         pub_inputs: &<ElectionPoSt<'a, H> as ProofScheme<'a>>::PublicInputs,
         pub_params: &<ElectionPoSt<'a, H> as ProofScheme<'a>>::PublicParams,
         _partition_k: Option<usize>,
-    ) -> Vec<Fr> {
+    ) -> Result<Vec<Fr>> {
         let mut inputs = Vec::new();
 
         let por_pub_params = merklepor::PublicParams {
@@ -95,7 +96,7 @@ where
                 pub_inputs.sector_challenge_index,
                 n as u64,
                 pub_params.sector_size,
-            );
+            )?;
             for i in 0..election_post::POST_CHALLENGED_NODES {
                 let por_pub_inputs = merklepor::PublicInputs {
                     commitment: None,
@@ -105,7 +106,7 @@ where
                     &por_pub_inputs,
                     &por_pub_params,
                     None,
-                );
+                )?;
 
                 inputs.extend(por_inputs);
             }
@@ -114,15 +115,15 @@ where
         // 3. Inputs for verifying partial_ticket generation
         inputs.push(pub_inputs.partial_ticket);
 
-        inputs
+        Ok(inputs)
     }
 
     fn circuit(
         pub_in: &<ElectionPoSt<'a, H> as ProofScheme<'a>>::PublicInputs,
         _priv_in: <ElectionPoStCircuit<'a, Bls12, H> as CircuitComponent>::ComponentPrivateInputs,
         vanilla_proof: &<ElectionPoSt<'a, H> as ProofScheme<'a>>::Proof,
         _pub_params: &<ElectionPoSt<'a, H> as ProofScheme<'a>>::PublicParams,
-    ) -> ElectionPoStCircuit<'a, Bls12, H> {
+    ) -> Result<ElectionPoStCircuit<'a, Bls12, H>> {
         let comm_r = pub_in.comm_r.into();
         let comm_c = vanilla_proof.comm_c.into();
         let comm_q = vanilla_proof.comm_q.into();
@@ -140,7 +141,7 @@ where
             .map(|v| v.iter().map(|p| Some(((*p).0.into(), p.1))).collect())
             .collect();
 
-        ElectionPoStCircuit {
+        Ok(ElectionPoStCircuit {
             params: &*JJ_PARAMS,
             leafs,
             comm_r: Some(comm_r),
@@ -153,7 +154,7 @@ where
             prover_id: bytes_into_bits_opt(&pub_in.prover_id[..]),
             sector_id: Some(u64::from(pub_in.sector_id)),
             _h: PhantomData,
-        }
+        })
     }
 
     fn blank_circuit(
@@ -388,7 +389,7 @@ mod tests {
                 .flat_map(|_| fr_into_bytes::<Bls12>(&Fr::random(rng)))
                 .collect();
 
-            let graph = BucketGraph::<PedersenHasher>::new(32, BASE_DEGREE, 0, new_seed());
+            let graph = BucketGraph::<PedersenHasher>::new(32, BASE_DEGREE, 0, new_seed()).unwrap();
             let tree = graph.merkle_tree(data.as_slice()).unwrap();
             trees.insert(i.into(), tree);
         }
@@ -476,7 +477,8 @@ mod tests {
             &pub_inputs,
             &pub_params,
             None,
-        );
+        )
+        .unwrap();
         let expected_inputs = cs.get_inputs();
 
         for ((input, label), generated_input) in
@@ -515,7 +517,7 @@ mod tests {
                 .flat_map(|_| fr_into_bytes::<Bls12>(&Fr::random(rng)))
                 .collect();
 
-            let graph = BucketGraph::<PedersenHasher>::new(32, BASE_DEGREE, 0, new_seed());
+            let graph = BucketGraph::<PedersenHasher>::new(32, BASE_DEGREE, 0, new_seed()).unwrap();
             let tree = graph.merkle_tree(data.as_slice()).unwrap();
             trees.insert(i.into(), tree);
         }
@@ -557,7 +559,8 @@ mod tests {
 
         {
             let (circuit, inputs) =
-                ElectionPoStCompound::circuit_for_test(&pub_params, &pub_inputs, &priv_inputs);
+                ElectionPoStCompound::circuit_for_test(&pub_params, &pub_inputs, &priv_inputs)
+                    .unwrap();
 
             let mut cs = TestConstraintSystem::new();
 
@@ -578,7 +581,8 @@ mod tests {
         // Use this to debug differences between blank and regular circuit generation.
         {
             let (circuit1, _inputs) =
-                ElectionPoStCompound::circuit_for_test(&pub_params, &pub_inputs, &priv_inputs);
+                ElectionPoStCompound::circuit_for_test(&pub_params, &pub_inputs, &priv_inputs)
+                    .unwrap();
             let blank_circuit =
                 ElectionPoStCompound::<PedersenHasher>::blank_circuit(&pub_params.vanilla_params);