Consistent use of Iterators for Dkg and Resharing.

Author: akonring

timeboost-crypto/src/feldman.rs

@@ -302,41 +302,42 @@ impl<C: CurveGroup> KeyResharing<Self> for FeldmanVss<C> {
         old_pp: &FeldmanVssPublicParam<C>,
         new_pp: &FeldmanVssPublicParam<C>,
         recv_node_idx: usize,
-        reshares: impl ExactSizeIterator<Item = (usize, C::ScalarField, FeldmanCommitment<C>)> + Clone,
+        reshares: impl Iterator<Item = (usize, C::ScalarField, FeldmanCommitment<C>)>,
     ) -> Result<(C::ScalarField, FeldmanCommitment<C>), VssError> {
-        // input validation
         let n = old_pp.n.get();
-        if reshares.len() == 0 {
-            return Err(VssError::EmptyReshare);
-        }
-        for (idx, _, _) in reshares.clone() {
+
+        let mut eval_points = Vec::new();
+        let mut recv_shares = Vec::new();
+        let mut row_commitments = Vec::new();
+
+        for (idx, share, commitment) in reshares {
             if idx >= n {
                 return Err(VssError::IndexOutOfBound(n - 1, idx));
             }
+            eval_points.push(C::ScalarField::from(idx as u64 + 1));
+            recv_shares.push(share);
+            row_commitments.push(commitment);
+        }
+
+        if eval_points.is_empty() {
+            return Err(VssError::EmptyReshare);
         }
 
         let new_n = new_pp.n.get();
         let new_t = new_pp.t.get();
         if recv_node_idx >= new_n {
             return Err(VssError::IndexOutOfBound(new_n - 1, recv_node_idx));
         }
-        for (_, _, row_commitment) in reshares.clone() {
-            if row_commitment.len() != new_t {
-                return Err(VssError::InvalidCommitment);
-            }
+
+        if row_commitments.iter().any(|c| c.len() != new_t) {
+            return Err(VssError::InvalidCommitment);
         }
 
         // interpolate reshares to get new secret share
-        let eval_points: Vec<_> = reshares
-            .clone()
-            .map(|(idx, _, _)| C::ScalarField::from(idx as u64 + 1))
-            .collect();
-        let recv_reshares: Vec<_> = reshares.clone().map(|(_, share, _)| share).collect();
-        let new_secret = interpolate::<C>(&eval_points, &recv_reshares)
+        let new_secret = interpolate::<C>(&eval_points, &recv_shares)
             .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| {
@@ -346,6 +347,7 @@ impl<C: CurveGroup> KeyResharing<Self> for FeldmanVss<C> {
                     .map_err(|e| VssError::FailedCombine(e.to_string()))
             })
             .collect::<Result<Vec<_>, VssError>>()?;
+
         let new_commitment = C::normalize_batch(&new_commitment);
 
         Ok((new_secret, new_commitment.into()))

timeboost-crypto/src/traits/dkg.rs

@@ -112,7 +112,7 @@ pub trait KeyResharing<VSS: VerifiableSecretSharing> {
         old_pp: &VSS::PublicParam,
         new_pp: &VSS::PublicParam,
         recv_node_idx: usize,
-        reshares: impl ExactSizeIterator<Item = (usize, VSS::SecretShare, VSS::Commitment)> + Clone,
+        reshares: impl Iterator<Item = (usize, VSS::SecretShare, VSS::Commitment)>,
     ) -> Result<(VSS::Secret, VSS::Commitment), VssError>;
 }
 

timeboost-types/src/decryption.rs

@@ -81,7 +81,7 @@ impl ThresholdKey {
         dealings: I,
     ) -> anyhow::Result<Self>
     where
-        I: ExactSizeIterator<Item = (usize, VssShare, VssCommitment)> + Clone,
+        I: Iterator<Item = (usize, VssShare, VssCommitment)>,
     {
         let old_pp = FeldmanVssPublicParam::from(old_committee);
         let new_pp = FeldmanVssPublicParam::from(new_committee);
@@ -600,38 +600,28 @@ impl<'a> DkgSubsetRef<'a> {
                 )?;
 
                 dealings_iter.result()?;
-
                 Ok(dec_key)
             }
             Some(combkey) => {
-                let Some(prev) = prev else {
-                    return Err(anyhow!("previous key store missing"));
-                };
+                let prev = prev.ok_or_else(|| anyhow!("previous key store missing"))?;
+                let mut dealings_iter = ResultIter::new(self.bundles.iter().map(|b| {
+                    let node_idx = b.origin().0.into();
+                    let pub_share = combkey
+                        .get_pub_share(node_idx)
+                        .ok_or(VessError::FailedVerification)?;
+                    vess.decrypt_reshare(curr.committee(), dkg_sk, b.vess_ct(), DKG_AAD, *pub_share)
+                        .map(|s| (node_idx, s, b.comm().clone()))
+                }));
 
-                let dealings: Vec<_> = self
-                    .bundles
-                    .iter()
-                    .map(|b| {
-                        let node_idx = b.origin().0.into();
-                        let pub_share = combkey
-                            .get_pub_share(node_idx)
-                            .ok_or(VessError::FailedVerification)?;
-                        let s = vess.decrypt_reshare(
-                            curr.committee(),
-                            dkg_sk,
-                            b.vess_ct(),
-                            DKG_AAD,
-                            *pub_share,
-                        )?;
-                        Ok((node_idx, s, b.comm().clone()))
-                    })
-                    .collect::<Result<Vec<_>, VessError>>()?;
-                ThresholdKey::from_resharing(
+                let dec_key = ThresholdKey::from_resharing(
                     prev.committee(),
                     curr.committee(),
                     dkg_sk.node_idx(),
-                    dealings.into_iter(),
-                )
+                    &mut dealings_iter,
+                )?;
+
+                dealings_iter.result()?;
+                Ok(dec_key)
             }
         }
     }