improve combine() api to accept sized iter

Author: alxiong

timeboost-crypto/src/feldman.rs

@@ -246,19 +246,17 @@ impl<C: CurveGroup> KeyResharing<Self> for FeldmanVss<C> {
     fn combine(
         old_pp: &FeldmanVssPublicParam,
         new_pp: &FeldmanVssPublicParam,
-        send_node_indices: &[usize],
-        row_commitments: &[FeldmanCommitment<C>],
         recv_node_idx: usize,
-        recv_reshares: &[C::ScalarField],
+        reshares: impl ExactSizeIterator<Item = (usize, C::ScalarField, FeldmanCommitment<C>)> + Clone,
     ) -> Result<(C::ScalarField, FeldmanCommitment<C>), VssError> {
         // input validation
         let n = old_pp.n.get();
-        if send_node_indices.is_empty() || row_commitments.is_empty() || recv_reshares.is_empty() {
+        if reshares.len() == 0 {
             return Err(VssError::EmptyReshare);
         }
-        for idx in send_node_indices.iter() {
-            if *idx >= n {
-                return Err(VssError::IndexOutOfBound(n - 1, *idx));
+        for (idx, _, _) in reshares.clone() {
+            if idx >= n {
+                return Err(VssError::IndexOutOfBound(n - 1, idx));
             }
         }
 
@@ -267,24 +265,23 @@ impl<C: CurveGroup> KeyResharing<Self> for FeldmanVss<C> {
         if recv_node_idx >= new_n {
             return Err(VssError::IndexOutOfBound(new_n - 1, recv_node_idx));
         }
-        if row_commitments.iter().any(|cm| cm.len() != new_t) {
-            return Err(VssError::InvalidCommitment);
-        }
-
-        let subset_size = recv_reshares.len();
-        if send_node_indices.len() != subset_size || row_commitments.len() != subset_size {
-            return Err(VssError::MismatchedInputLength);
+        for (_, _, row_commitment) in reshares.clone() {
+            if row_commitment.len() != new_t {
+                return Err(VssError::InvalidCommitment);
+            }
         }
 
         // interpolate reshares to get new secret share
-        let eval_points: Vec<_> = send_node_indices
-            .iter()
-            .map(|&idx| C::ScalarField::from(idx as u64 + 1))
+        let eval_points: Vec<_> = reshares
+            .clone()
+            .map(|(idx, _, _)| C::ScalarField::from(idx as u64 + 1))
             .collect();
-        let new_secret = interpolate::<C>(&eval_points, recv_reshares)
+        let recv_reshares: Vec<_> = reshares.clone().map(|(_, share, _)| share).collect();
+        let new_secret = interpolate::<C>(&eval_points, &recv_reshares)
             .map_err(|e| VssError::FailedCombine(e.to_string()))?;
 
         // interpolate in the exponent to get new Feldman commitment
+        let row_commitments: Vec<_> = reshares.map(|(_, _, commitment)| commitment).collect();
         let new_commitment = (0..new_t)
             .into_par_iter()
             .map(|j| {
@@ -455,15 +452,10 @@ mod tests {
             let selected_row_commitments: Vec<FeldmanCommitment<_>> =
                 (0..old_t).map(|i| row_commitments[i].clone()).collect();
 
-            let (new_secret_share, new_commitment) = FeldmanVss::<G1Projective>::combine(
-                &old_pp,
-                &new_pp,
-                &(0..old_t).collect::<Vec<_>>(),
-                &selected_row_commitments,
-                j,
-                &recv_reshares,
-            )
-            .unwrap();
+            let reshares_iter =
+                (0..old_t).map(|i| (i, recv_reshares[i], selected_row_commitments[i].clone()));
+            let (new_secret_share, new_commitment) =
+                FeldmanVss::<G1Projective>::combine(&old_pp, &new_pp, j, reshares_iter).unwrap();
 
             new_shares.push(new_secret_share);
             new_commitments.push(new_commitment);

timeboost-crypto/src/traits/dkg.rs

@@ -94,10 +94,8 @@ pub trait KeyResharing<VSS: VerifiableSecretSharing> {
     fn combine(
         old_pp: &VSS::PublicParam,
         new_pp: &VSS::PublicParam,
-        send_node_indices: &[usize],
-        row_commitments: &[VSS::Commitment],
         recv_node_idx: usize,
-        recv_reshares: &[VSS::SecretShare],
+        reshares: impl ExactSizeIterator<Item = (usize, VSS::SecretShare, VSS::Commitment)> + Clone,
     ) -> Result<(VSS::Secret, VSS::Commitment), VssError>;
 }