style: apply feedback

filecoin-project · Aug 11, 2023 · f3e90a2 · f3e90a2
1 parent 33613ab
commit f3e90a2
Show file tree

Hide file tree

Showing 2 changed files with 30 additions and 45 deletions.
diff --git a/storage-proofs-core/src/merkle/proof.rs b/storage-proofs-core/src/merkle/proof.rs
@@ -500,57 +500,39 @@ impl<
         root: H::Domain,
         mut path: Vec<(Vec<H::Domain>, usize)>,
     ) -> Self {
-        let has_sub_path = SubTreeArity::to_usize() != 0;
-        let has_top_path = TopTreeArity::to_usize() != 0;
-        let base_path_len = path.len() - has_sub_path as usize - has_top_path as usize;
-
-        let mut path = path.drain(..);
-
-        let base_path = (&mut path)
-            .take(base_path_len)
-            .map(PathElement::from)
-            .collect::<Vec<_>>()
-            .into();
-
-        if !has_sub_path {
-            return MerkleProof {
+        if SubTreeArity::to_usize() == 0 {
+            let base_path = path.into_iter().map(PathElement::from).collect::<Vec<_>>();
+            MerkleProof {
                 data: ProofData::Single(SingleProof {
                     leaf,
                     root,
-                    path: base_path,
+                    path: base_path.into(),
                 }),
-            };
-        }
-
-        let sub_path = path
-            .next()
-            .map(|elem| InclusionPath::from(vec![PathElement::from(elem)]))
-            .expect("path should not be empty");
-
-        if !has_top_path {
-            return MerkleProof {
+            }
+        } else if TopTreeArity::to_usize() == 0 {
+            let sub_elem = path.pop().expect("path should not be empty");
+            let base_path = path.into_iter().map(PathElement::from).collect::<Vec<_>>();
+            MerkleProof {
                 data: ProofData::Sub(SubProof {
                     leaf,
                     root,
-                    base_proof: base_path,
-                    sub_proof: sub_path,
+                    base_proof: base_path.into(),
+                    sub_proof: vec![PathElement::from(sub_elem)].into(),
                 }),
-            };
-        }
-
-        let top_path = path
-            .next()
-            .map(|elem| InclusionPath::from(vec![PathElement::from(elem)]))
-            .expect("path should not be empty");
-
-        MerkleProof {
-            data: ProofData::Top(TopProof {
-                leaf,
-                root,
-                base_proof: base_path,
-                sub_proof: sub_path,
-                top_proof: top_path,
-            }),
+            }
+        } else {
+            let top_elem = path.pop().expect("path should not be empty");
+            let sub_elem = path.pop().expect("path should not be empty");
+            let base_path = path.into_iter().map(PathElement::from).collect::<Vec<_>>();
+            MerkleProof {
+                data: ProofData::Top(TopProof {
+                    leaf,
+                    root,
+                    base_proof: base_path.into(),
+                    sub_proof: vec![PathElement::from(sub_elem)].into(),
+                    top_proof: vec![PathElement::from(top_elem)].into(),
+                }),
+            }
         }
     }
 }

diff --git a/storage-proofs-porep/src/stacked/vanilla/params.rs b/storage-proofs-porep/src/stacked/vanilla/params.rs
@@ -334,8 +334,11 @@ impl<Tree: MerkleTreeTrait, G: Hasher> Proof<Tree, G> {
 
         let labeling_proofs: Vec<LabelingProof<Tree::Hasher>> = (0..num_layers)
             .map(|layer_index| {
-                let has_exp_parents = (layer_index != 0) as usize;
-                let layer_parents = num_drg_parents + has_exp_parents * num_exp_parents;
+                let layer_parents = if layer_index == 0 {
+                    num_drg_parents
+                } else {
+                    num_drg_parents + num_exp_parents
+                };
                 let (layer, prev_layer) = (layer_index + 1, layer_index);
 
                 let repeated_parent_labels = drg_col_proofs