Rename all params

poly-commit/src/linear_codes/brakedown.rs

@@ -79,13 +79,13 @@ where
     }
 
     fn leaf_hash_param(&self) -> &<<C as Config>::LeafHash as CRHScheme>::Parameters {
-        &self.leaf_hash_params
+        &self.leaf_hash_param
     }
 
     fn two_to_one_hash_param(
         &self,
     ) -> &<<C as Config>::TwoToOneHash as TwoToOneCRHScheme>::Parameters {
-        &self.two_to_one_params
+        &self.two_to_one_hash_param
     }
 
     fn col_hash_params(&self) -> &<H as CRHScheme>::Parameters {
@@ -104,8 +104,8 @@ where
         rng: &mut R,
         poly_len: usize,
         check_well_formedness: bool,
-        leaf_hash_params: LeafParam<C>,
-        two_to_one_params: TwoToOneParam<C>,
+        leaf_hash_param: LeafParam<C>,
+        two_to_one_hash_param: TwoToOneParam<C>,
         col_hash_params: H::Parameters,
     ) -> Self {
         let sec_param = 128;
@@ -136,8 +136,8 @@ where
             a_mats,
             b_mats,
             check_well_formedness,
-            leaf_hash_params,
-            two_to_one_params,
+            leaf_hash_param,
+            two_to_one_hash_param,
             col_hash_params,
         )
     }
@@ -156,8 +156,8 @@ where
         a_mats: Vec<SprsMat<F>>,
         b_mats: Vec<SprsMat<F>>,
         check_well_formedness: bool,
-        leaf_hash_params: LeafParam<C>,
-        two_to_one_params: TwoToOneParam<C>,
+        leaf_hash_param: LeafParam<C>,
+        two_to_one_hash_param: TwoToOneParam<C>,
         col_hash_params: H::Parameters,
     ) -> Self {
         let m_ext = if a_dims.is_empty() {
@@ -196,8 +196,8 @@ where
             a_mats,
             b_mats,
             check_well_formedness,
-            leaf_hash_params,
-            two_to_one_params,
+            leaf_hash_param,
+            two_to_one_hash_param,
             col_hash_params,
         }
     }

poly-commit/src/linear_codes/data_structures.rs

@@ -51,10 +51,10 @@ pub struct BrakedownPCParams<F: PrimeField, C: Config, H: CRHScheme> {
     pub(crate) check_well_formedness: bool,
     /// Parameters for hash function of Merkle tree leaves
     #[derivative(Debug = "ignore")]
-    pub(crate) leaf_hash_params: LeafParam<C>,
+    pub(crate) leaf_hash_param: LeafParam<C>,
     /// Parameters for hash function of Merke tree combining two nodes into one
     #[derivative(Debug = "ignore")]
-    pub(crate) two_to_one_params: TwoToOneParam<C>,
+    pub(crate) two_to_one_hash_param: TwoToOneParam<C>,
     // Parameters for obtaining leaf digest from leaf value.
     #[derivative(Debug = "ignore")]
     pub(crate) col_hash_params: H::Parameters,

poly-commit/src/linear_codes/mod.rs

@@ -89,8 +89,8 @@ where
         max_degree: usize,
         num_vars: Option<usize>,
         rng: &mut R,
-        leaf_hash_params: <<C as Config>::LeafHash as CRHScheme>::Parameters,
-        two_to_one_params: <<C as Config>::TwoToOneHash as TwoToOneCRHScheme>::Parameters,
+        leaf_hash_param: <<C as Config>::LeafHash as CRHScheme>::Parameters,
+        two_to_one_hash_param: <<C as Config>::TwoToOneHash as TwoToOneCRHScheme>::Parameters,
         col_hash_params: H::Parameters,
     ) -> Self::LinCodePCParams;
 
@@ -189,17 +189,17 @@ where
         num_vars: Option<usize>,
         rng: &mut R,
     ) -> Result<Self::UniversalParams, Self::Error> {
-        let leaf_hash_params = <C::LeafHash as CRHScheme>::setup(rng).unwrap();
-        let two_to_one_params = <C::TwoToOneHash as TwoToOneCRHScheme>::setup(rng)
+        let leaf_hash_param = <C::LeafHash as CRHScheme>::setup(rng).unwrap();
+        let two_to_one_hash_param = <C::TwoToOneHash as TwoToOneCRHScheme>::setup(rng)
             .unwrap()
             .clone();
         let col_hash_params = <H as CRHScheme>::setup(rng).unwrap();
         let pp = L::setup::<R>(
             max_degree,
             num_vars,
             rng,
-            leaf_hash_params,
-            two_to_one_params,
+            leaf_hash_param,
+            two_to_one_hash_param,
             col_hash_params,
         );
         let real_max_degree = <Self::UniversalParams as PCUniversalParams>::max_degree(&pp);
@@ -263,7 +263,7 @@ where
                 leaves,
             };
             let mut leaves: Vec<C::Leaf> =
-                state.leaves.clone().into_iter().map(|h| h.into()).collect(); // TODO cfg_inter
+                state.leaves.clone().into_iter().map(|h| h.into()).collect();
             let col_tree = create_merkle_tree::<C>(
                 &mut leaves,
                 ck.leaf_hash_param(),
@@ -343,7 +343,7 @@ where
                 leaves: col_hashes,
             } = states[i];
             let mut col_hashes: Vec<C::Leaf> =
-                col_hashes.clone().into_iter().map(|h| h.into()).collect(); // TODO cfg_inter
+                col_hashes.clone().into_iter().map(|h| h.into()).collect();
 
             let col_tree = create_merkle_tree::<C>(
                 &mut col_hashes,
@@ -429,9 +429,9 @@ where
                 )
             ));
         }
-        let leaf_hash_params: &<<C as Config>::LeafHash as CRHScheme>::Parameters =
+        let leaf_hash_param: &<<C as Config>::LeafHash as CRHScheme>::Parameters =
             vk.leaf_hash_param();
-        let two_to_one_params: &<<C as Config>::TwoToOneHash as TwoToOneCRHScheme>::Parameters =
+        let two_to_one_hash_param: &<<C as Config>::TwoToOneHash as TwoToOneCRHScheme>::Parameters =
             vk.two_to_one_hash_param();
 
         for (i, labeled_commitment) in labeled_commitments.iter().enumerate() {
@@ -508,7 +508,7 @@ where
                     return Err(Error::InvalidCommitment);
                 }
 
-                path.verify(leaf_hash_params, two_to_one_params, root, leaf.clone())
+                path.verify(leaf_hash_param, two_to_one_hash_param, root, leaf.clone())
                     .map_err(|_| Error::InvalidCommitment)?;
             }
 

poly-commit/src/linear_codes/multilinear_brakedown/mod.rs

@@ -44,16 +44,16 @@ where
         _max_degree: usize,
         num_vars: Option<usize>,
         rng: &mut R,
-        leaf_hash_params: <<C as Config>::LeafHash as CRHScheme>::Parameters,
-        two_to_one_params: <<C as Config>::TwoToOneHash as TwoToOneCRHScheme>::Parameters,
+        leaf_hash_param: <<C as Config>::LeafHash as CRHScheme>::Parameters,
+        two_to_one_hash_param: <<C as Config>::TwoToOneHash as TwoToOneCRHScheme>::Parameters,
         col_hash_params: H::Parameters,
     ) -> Self::LinCodePCParams {
         Self::LinCodePCParams::default(
             rng,
             1 << num_vars.unwrap(),
             true,
-            leaf_hash_params,
-            two_to_one_params,
+            leaf_hash_param,
+            two_to_one_hash_param,
             col_hash_params,
         )
     }

poly-commit/src/linear_codes/multilinear_brakedown/tests.rs

@@ -86,8 +86,8 @@ mod tests {
         let mut rng = &mut test_rng();
         let num_vars = 11;
         // just to make sure we have the right degree given the FFT domain for our field
-        let leaf_hash_params = <LeafH as CRHScheme>::setup(&mut rng).unwrap();
-        let two_to_one_params = <CompressH as TwoToOneCRHScheme>::setup(&mut rng)
+        let leaf_hash_param = <LeafH as CRHScheme>::setup(&mut rng).unwrap();
+        let two_to_one_hash_param = <CompressH as TwoToOneCRHScheme>::setup(&mut rng)
             .unwrap()
             .clone();
         let col_hash_params = <ColHasher<Fr, Blake2s256> as CRHScheme>::setup(&mut rng).unwrap();
@@ -98,8 +98,8 @@ mod tests {
                 rng,
                 1 << num_vars,
                 check_well_formedness,
-                leaf_hash_params,
-                two_to_one_params,
+                leaf_hash_param,
+                two_to_one_hash_param,
                 col_hash_params,
             );