Remove the public_key field from AggregatedTranscript

And calculate it on the fly if needed.

Author: fjarri

ferveo/src/api.rs

@@ -290,7 +290,7 @@ impl AggregatedTranscript {
         let domain =
             GeneralEvaluationDomain::<Fr>::new(validators_num as usize)
                 .expect("Unable to construct an evaluation domain");
-        let is_valid_optimistic = self.0.aggregate.verify_optimistic();
+        let is_valid_optimistic = self.0.aggregate().verify_optimistic();
         if !is_valid_optimistic {
             return Err(Error::InvalidTranscriptAggregate);
         }
@@ -307,8 +307,8 @@ impl AggregatedTranscript {
             .collect::<Vec<_>>();
         // This check also includes `verify_full`. See impl. for details.
         do_verify_aggregation(
-            &self.0.aggregate.coeffs,
-            &self.0.aggregate.shares,
+            &self.0.aggregate().coeffs,
+            &self.0.aggregate().shares,
             &validators,
             &domain,
             &pvss_list,
@@ -342,7 +342,7 @@ impl AggregatedTranscript {
                     .map(|domain_point| (v.share_index, domain_point))
             })
             .collect::<HashMap<u32, ferveo_tdec::DomainPoint<E>>>();
-        self.0.aggregate.create_decryption_share_precomputed(
+        self.0.aggregate().create_decryption_share_precomputed(
             &ciphertext_header.0,
             aad,
             validator_keypair,
@@ -368,7 +368,7 @@ impl AggregatedTranscript {
             Error::DealerNotInValidatorSet(my_public_key.to_string())
         })?;
 
-        let share = self.0.aggregate.create_decryption_share_simple(
+        let share = self.0.aggregate().create_decryption_share_simple(
             &ciphertext_header.0,
             aad,
             validator_keypair,
@@ -382,7 +382,7 @@ impl AggregatedTranscript {
     }
 
     pub fn public_key(&self) -> DkgPublicKey {
-        DkgPublicKey(self.0.public_key)
+        DkgPublicKey(self.0.public_key())
     }
 
     pub fn refresh(
@@ -393,7 +393,7 @@ impl AggregatedTranscript {
         // TODO: Aggregates structs should be refactored, this is a bit of a mess - #162
         let updated_aggregate = self
             .0
-            .aggregate
+            .aggregate()
             .refresh(update_transcripts, validator_keys_map)
             .unwrap();
         let eeww =
@@ -409,7 +409,7 @@ impl AggregatedTranscript {
     ) -> Result<Self> {
         let new_aggregate = self
             .0
-            .aggregate
+            .aggregate()
             .finalize_handover(&handover_transcript.0, validator_keypair)
             .unwrap();
         // TODO: Aggregates structs should be refactored, this is a bit of a mess - #162

ferveo/src/dkg.rs

@@ -238,7 +238,7 @@ impl<E: Pairing> PubliclyVerifiableDkg<E> {
             .ok_or(Error::InvalidShareIndex(handover_slot_index))?;
 
         let departing_blinded_share = aggregate
-            .aggregate
+            .aggregate()
             .get_share_for_validator(departing_validator)?;
 
         Ok(refresh::HandoverTranscript::<E>::new(

ferveo/src/lib.rs

@@ -149,7 +149,7 @@ mod test_dkg_full {
         let server_aggregate =
             AggregatedTranscript::from_transcripts(transcripts).unwrap();
         assert!(server_aggregate
-            .aggregate
+            .aggregate()
             .verify_aggregation(dkg, transcripts)
             .unwrap());
 
@@ -161,7 +161,7 @@ mod test_dkg_full {
                         .get_validator(&validator_keypair.public_key())
                         .unwrap();
                     server_aggregate
-                        .aggregate
+                        .aggregate()
                         .create_decryption_share_simple(
                             ciphertext_header,
                             aad,
@@ -207,13 +207,13 @@ mod test_dkg_full {
         let local_aggregate =
             AggregatedTranscript::from_transcripts(&transcripts).unwrap();
         assert!(local_aggregate
-            .aggregate
+            .aggregate()
             .verify_aggregation(&dkg, &transcripts)
             .unwrap());
         let ciphertext = ferveo_tdec::encrypt::<E>(
             SecretBox::new(MSG.into()),
             AAD,
-            &local_aggregate.public_key,
+            &local_aggregate.public_key(),
             rng,
         )
         .unwrap();
@@ -259,13 +259,13 @@ mod test_dkg_full {
         let local_aggregate =
             AggregatedTranscript::from_transcripts(&transcripts).unwrap();
         assert!(local_aggregate
-            .aggregate
+            .aggregate()
             .verify_aggregation(&dkg, &transcripts)
             .unwrap());
         let ciphertext = ferveo_tdec::encrypt::<E>(
             SecretBox::new(MSG.into()),
             AAD,
-            &local_aggregate.public_key,
+            &local_aggregate.public_key(),
             rng,
         )
         .unwrap();
@@ -299,7 +299,7 @@ mod test_dkg_full {
                         .get_validator(&validator_keypair.public_key())
                         .unwrap();
                     local_aggregate
-                        .aggregate
+                        .aggregate()
                         .create_decryption_share_precomputed(
                             &ciphertext.header().unwrap(),
                             AAD,
@@ -344,13 +344,13 @@ mod test_dkg_full {
         let local_aggregate =
             AggregatedTranscript::from_transcripts(&transcripts).unwrap();
         assert!(local_aggregate
-            .aggregate
+            .aggregate()
             .verify_aggregation(&dkg, &transcripts)
             .unwrap());
         let ciphertext = ferveo_tdec::encrypt::<E>(
             SecretBox::new(MSG.into()),
             AAD,
-            &local_aggregate.public_key,
+            &local_aggregate.public_key(),
             rng,
         )
         .unwrap();
@@ -365,7 +365,7 @@ mod test_dkg_full {
             );
 
         izip!(
-            &local_aggregate.aggregate.shares,
+            &local_aggregate.aggregate().shares,
             &validator_keypairs,
             &decryption_shares,
         )
@@ -386,7 +386,7 @@ mod test_dkg_full {
         let mut with_bad_decryption_share = decryption_share.clone();
         with_bad_decryption_share.decryption_share = TargetField::zero();
         assert!(!with_bad_decryption_share.verify(
-            &local_aggregate.aggregate.shares[0],
+            &local_aggregate.aggregate().shares[0],
             &validator_keypairs[0].public_key().encryption_key,
             &ciphertext,
         ));
@@ -395,7 +395,7 @@ mod test_dkg_full {
         let mut with_bad_checksum = decryption_share;
         with_bad_checksum.validator_checksum.checksum = G1Affine::zero();
         assert!(!with_bad_checksum.verify(
-            &local_aggregate.aggregate.shares[0],
+            &local_aggregate.aggregate().shares[0],
             &validator_keypairs[0].public_key().encryption_key,
             &ciphertext,
         ));
@@ -427,13 +427,13 @@ mod test_dkg_full {
         let local_aggregate =
             AggregatedTranscript::from_transcripts(&transcripts).unwrap();
         assert!(local_aggregate
-            .aggregate
+            .aggregate()
             .verify_aggregation(&dkg, &transcripts)
             .unwrap());
         let ciphertext = ferveo_tdec::encrypt::<E>(
             SecretBox::new(MSG.into()),
             AAD,
-            &local_aggregate.public_key,
+            &local_aggregate.public_key(),
             rng,
         )
         .unwrap();
@@ -535,7 +535,7 @@ mod test_dkg_full {
                 let decryption_share =
                     AggregatedTranscript::from_transcripts(&transcripts)
                         .unwrap()
-                        .aggregate
+                        .aggregate()
                         .create_decryption_share_simple(
                             &ciphertext.header().unwrap(),
                             AAD,
@@ -619,15 +619,15 @@ mod test_dkg_full {
         let local_aggregate =
             AggregatedTranscript::from_transcripts(&transcripts).unwrap();
         assert!(local_aggregate
-            .aggregate
+            .aggregate()
             .verify_aggregation(&dkg, &transcripts)
             .unwrap());
 
         // Ciphertext created from the aggregate public key
         let ciphertext = ferveo_tdec::encrypt::<E>(
             SecretBox::new(MSG.into()),
             AAD,
-            &local_aggregate.public_key,
+            &local_aggregate.public_key(),
             rng,
         )
         .unwrap();
@@ -665,12 +665,12 @@ mod test_dkg_full {
         // Participants distribute UpdateTranscripts and update their shares
         // accordingly. The result is a new, joint AggregatedTranscript.
         let new_aggregate = local_aggregate
-            .aggregate
+            .aggregate()
             .refresh(&update_transcripts, &validator_map)
             .unwrap();
 
         // TODO: Assert new aggregate is different than original, including coefficients
-        assert_ne!(local_aggregate.aggregate, new_aggregate);
+        assert_ne!(local_aggregate.aggregate(), &new_aggregate);
 
         // TODO: Show that all participants obtain the same new aggregate transcript.
 
@@ -736,15 +736,15 @@ mod test_dkg_full {
         let local_aggregate =
             AggregatedTranscript::from_transcripts(&transcripts).unwrap();
         assert!(local_aggregate
-            .aggregate
+            .aggregate()
             .verify_aggregation(&dkg, &transcripts)
             .unwrap());
 
         // Ciphertext created from the aggregate public key
         let ciphertext = ferveo_tdec::encrypt::<E>(
             SecretBox::new(MSG.into()),
             AAD,
-            &local_aggregate.public_key,
+            &local_aggregate.public_key(),
             rng,
         )
         .unwrap();
@@ -797,7 +797,7 @@ mod test_dkg_full {
         // We're doing this for testing purposes, but in practice, this is done
         // by the departing participant when using the high-level API.
         let share_commitments = get_share_commitments_from_poly_commitments::<E>(
-            &local_aggregate.aggregate.coeffs,
+            &local_aggregate.aggregate().coeffs,
             &dkg.domain,
         );
         let share_commitment = ShareCommitment::<E>(
@@ -821,13 +821,13 @@ mod test_dkg_full {
         );
 
         let aggregate_after_handover = local_aggregate
-            .aggregate
+            .aggregate()
             .finalize_handover(&handover_transcript, departing_keypair)
             .unwrap();
 
         // If we use a different keypair, we should get an error
         let error = local_aggregate
-            .aggregate
+            .aggregate()
             .finalize_handover(
                 &handover_transcript,
                 &incoming_validator_keypair,
@@ -839,22 +839,23 @@ mod test_dkg_full {
         );
 
         // New aggregate is different than original...
-        assert_ne!(local_aggregate.aggregate, aggregate_after_handover);
+        assert_ne!(local_aggregate.aggregate(), &aggregate_after_handover);
 
         // ...but let's look a bit deeper:
         // - Polynomial coefficients are the same, which makes sense since the private shares are not changing
         assert_eq!(
-            local_aggregate.aggregate.coeffs,
+            local_aggregate.aggregate().coeffs,
             aggregate_after_handover.coeffs
         );
         // - The shares vector is different ...
         assert_ne!(
-            local_aggregate.aggregate.shares,
+            local_aggregate.aggregate().shares,
             aggregate_after_handover.shares
         );
         // ... but actually they only differ at the handover index
         for i in 0..shares_num {
-            let share_before = local_aggregate.aggregate.shares.get(i as usize);
+            let share_before =
+                local_aggregate.aggregate().shares.get(i as usize);
             let share_after = aggregate_after_handover.shares.get(i as usize);
             if i == handover_slot_index {
                 assert_ne!(share_before, share_after);

ferveo/src/pvss.rs

@@ -498,18 +498,13 @@ impl<E: Pairing, T: Aggregate> PubliclyVerifiableSS<E, T> {
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
-pub struct AggregatedTranscript<E: Pairing> {
+pub struct AggregatedTranscript<E: Pairing>(
     #[serde(bound(
         serialize = "PubliclyVerifiableSS<E, Aggregated>: Serialize",
         deserialize = "PubliclyVerifiableSS<E, Aggregated>: DeserializeOwned"
     ))]
-    pub aggregate: PubliclyVerifiableSS<E, Aggregated>,
-    #[serde(bound(
-        serialize = "ferveo_tdec::DkgPublicKey<E>: Serialize",
-        deserialize = "ferveo_tdec::DkgPublicKey<E>: DeserializeOwned"
-    ))]
-    pub public_key: ferveo_tdec::DkgPublicKey<E>,
-}
+    PubliclyVerifiableSS<E, Aggregated>,
+);
 
 // TODO: Add tests - #202
 impl<E: Pairing> AggregatedTranscript<E> {
@@ -523,11 +518,15 @@ impl<E: Pairing> AggregatedTranscript<E> {
     pub fn from_aggregate(
         aggregate: PubliclyVerifiableSS<E, Aggregated>,
     ) -> Result<Self> {
-        let public_key = ferveo_tdec::DkgPublicKey::<E>(aggregate.coeffs[0]);
-        Ok(AggregatedTranscript {
-            aggregate,
-            public_key,
-        })
+        Ok(AggregatedTranscript(aggregate))
+    }
+
+    pub fn aggregate(&self) -> &PubliclyVerifiableSS<E, Aggregated> {
+        &self.0
+    }
+
+    pub fn public_key(&self) -> ferveo_tdec::DkgPublicKey<E> {
+        ferveo_tdec::DkgPublicKey::<E>(self.0.coeffs[0])
     }
 }
 

ferveo/src/test_serialization.rs

@@ -57,8 +57,7 @@ const EXPECTED_AGGREGATED_TRANSCRIPT_BINARY_HEX: &str = concat![
     "600000000000000098c62bc13cf7570daf7bf84f9bbe3d58b97fbecfeb0ccac0",
     "645ea6d19032427a676ef46b7609a4c8026e5552f13f34c910fab79edb261228",
     "b79c027f01bc453d0ec7ecb62c78bb31b803efe71bab0b45f6ca65c85e9fe1a6",
-    "9ced417f4e3ef0253000000000000000b593fb0151e20229edcb564da0628ae7",
-    "28d6dbbfe58ca45b06e2058dfb684b0c2a6516cb69ff83d51229086d933c5ae4",
+    "9ced417f4e3ef025",
 ];
 const EXPECTED_DKG_PUBLIC_KEY_BINARY_HEX: &str = concat![
     "3000000000000000b593fb0151e20229edcb564da0628ae728d6dbbfe58ca45b",