PVSS trait refactoring (aptos-labs#18303)

* Merged HasAggregatableSubtranscript and NonaggregatableTranscript traits

* Implemented HasAggregatableSubtranscript for GenericSigning<T: HasAggregatableSubtranscript>

* Changed trait Aggregatable<C>: to trait Aggregatable: ... type SecretSharingConfig;

* Renamed SubTranscript to Subtranscript

Author: waamm

crates/aptos-batch-encryption/src/schemes/fptx.rs

@@ -21,7 +21,7 @@ use crate::{
 use anyhow::{anyhow, Result};
 use aptos_crypto::SecretSharingConfig as _;
 use aptos_dkg::pvss::{
-    traits::{Reconstructable as _, SubTranscript},
+    traits::{Reconstructable as _, Subtranscript},
     Player,
 };
 use ark_ec::AffineRepr as _;
@@ -84,13 +84,13 @@ impl BatchThresholdEncryption for FPTX {
 
     fn setup(
         digest_key: &Self::DigestKey,
-        pvss_public_params: &<Self::SubTranscript as SubTranscript>::PublicParameters,
+        pvss_public_params: &<Self::SubTranscript as Subtranscript>::PublicParameters,
         subtranscript_happypath: &Self::SubTranscript,
         subtranscript_slowpath: &Self::SubTranscript,
         tc_happypath: &Self::ThresholdConfig,
         tc_slowpath: &Self::ThresholdConfig,
         current_player: Player,
-        msk_share_decryption_key: &<Self::SubTranscript as SubTranscript>::DecryptPrivKey,
+        msk_share_decryption_key: &<Self::SubTranscript as Subtranscript>::DecryptPrivKey,
     ) -> Result<(
         Self::EncryptionKey,
         Vec<Self::VerificationKey>,

crates/aptos-batch-encryption/src/schemes/fptx_weighted.rs

@@ -24,7 +24,7 @@ use crate::{
 use anyhow::{anyhow, Result};
 use aptos_crypto::{weighted_config::WeightedConfigArkworks, SecretSharingConfig as _};
 use aptos_dkg::pvss::{
-    traits::{Reconstructable as _, SubTranscript},
+    traits::{Reconstructable as _, Subtranscript},
     Player,
 };
 use ark_ec::AffineRepr;
@@ -228,13 +228,13 @@ impl BatchThresholdEncryption for FPTXWeighted {
 
     fn setup(
         digest_key: &Self::DigestKey,
-        pvss_public_params: &<Self::SubTranscript as SubTranscript>::PublicParameters,
+        pvss_public_params: &<Self::SubTranscript as Subtranscript>::PublicParameters,
         subtranscript_happypath: &Self::SubTranscript,
         subtranscript_slowpath: &Self::SubTranscript,
         tc_happypath: &Self::ThresholdConfig,
         tc_slowpath: &Self::ThresholdConfig,
         current_player: Player,
-        msk_share_decryption_key: &<Self::SubTranscript as SubTranscript>::DecryptPrivKey,
+        msk_share_decryption_key: &<Self::SubTranscript as Subtranscript>::DecryptPrivKey,
     ) -> Result<(
         Self::EncryptionKey,
         Vec<Self::VerificationKey>,

crates/aptos-batch-encryption/src/tests/fptx_weighted_smoke.rs

@@ -110,9 +110,9 @@ fn weighted_smoke_with_setup_for_testing() {
     );
 }
 
-type T = aptos_dkg::pvss::chunky::UnsignedWeightedTranscript<crate::group::Pairing>;
-type C = WeightedConfigArkworks<Fr>;
-use crate::group::{Fr, G2Affine};
+type T = aptos_dkg::pvss::chunky::SignedWeightedTranscript<crate::group::Pairing>;
+// type C = WeightedConfigArkworks<Fr>;
+use crate::group::G2Affine;
 use aptos_crypto::{SigningKey, Uniform};
 use aptos_dkg::pvss::{
     test_utils::NoAux,
@@ -158,7 +158,7 @@ fn weighted_smoke_with_pvss() {
         .collect();
 
     // Test dealing
-    let subtrx_happypaths: Vec<<T as HasAggregatableSubtranscript<C>>::SubTranscript> = secrets
+    let subtrx_happypaths: Vec<<T as HasAggregatableSubtranscript>::Subtranscript> = secrets
         .iter()
         .enumerate()
         .map(|(i, s)| {
@@ -177,7 +177,7 @@ fn weighted_smoke_with_pvss() {
         })
         .collect();
 
-    let subtrx_slowpaths: Vec<<T as HasAggregatableSubtranscript<C>>::SubTranscript> = secrets
+    let subtrx_slowpaths: Vec<<T as HasAggregatableSubtranscript>::Subtranscript> = secrets
         .iter()
         .enumerate()
         .map(|(i, s)| {

crates/aptos-batch-encryption/src/traits.rs

@@ -2,14 +2,14 @@
 // Licensed pursuant to the Innovation-Enabling Source Code License, available at https://github.com/aptos-labs/aptos-core/blob/main/LICENSE
 use anyhow::Result;
 use aptos_crypto::player::Player;
-use aptos_dkg::pvss::traits::SubTranscript;
+use aptos_dkg::pvss::traits::Subtranscript;
 use ark_std::rand::{CryptoRng, RngCore};
 use serde::{de::DeserializeOwned, Serialize};
 use std::hash::Hash;
 
 pub trait BatchThresholdEncryption {
     type ThresholdConfig: aptos_crypto::SecretSharingConfig;
-    type SubTranscript: SubTranscript;
+    type SubTranscript: Subtranscript;
 
     /// An encryption key for the scheme. Allows for generating ciphertexts. If we want to actually
     /// deploy this scheme, the functionality here will have to be implemented in the SDK.
@@ -58,13 +58,13 @@ pub trait BatchThresholdEncryption {
 
     fn setup(
         digest_key: &Self::DigestKey,
-        pvss_public_params: &<Self::SubTranscript as SubTranscript>::PublicParameters,
+        pvss_public_params: &<Self::SubTranscript as Subtranscript>::PublicParameters,
         subtranscript_happypath: &Self::SubTranscript,
         subtranscript_slowpath: &Self::SubTranscript,
         tc_happypath: &Self::ThresholdConfig,
         tc_slowpath: &Self::ThresholdConfig,
         current_player: Player,
-        sk_share_decryption_key: &<Self::SubTranscript as SubTranscript>::DecryptPrivKey,
+        sk_share_decryption_key: &<Self::SubTranscript as Subtranscript>::DecryptPrivKey,
     ) -> Result<(
         Self::EncryptionKey,
         Vec<Self::VerificationKey>,

crates/aptos-dkg/benches/pvss.rs

@@ -16,7 +16,7 @@ use aptos_dkg::{
         },
         traits::transcript::{
             Aggregatable, AggregatableTranscript, HasAggregatableSubtranscript,
-            MalleableTranscript, NonAggregatableTranscript, Transcript, WithMaxNumShares,
+            MalleableTranscript, Transcript, WithMaxNumShares,
         },
         LowDegreeTest, WeightedConfigBlstrs,
     },
@@ -33,10 +33,7 @@ use rand::{rngs::ThreadRng, thread_rng, Rng};
 pub fn all_groups(c: &mut Criterion) {
     // unweighted BN254 PVSS with aggregatable subtranscript; only doing 2 because large configs are a bit slow and not relevant anyway
     for tc in get_threshold_configs_for_benchmarking().into_iter().take(2) {
-        subaggregatable_pvss_group::<
-            <ChunkyTranscript<Bn254> as Transcript>::SecretSharingConfig,
-            ChunkyTranscript<Bn254>,
-        >(&tc, c);
+        subaggregatable_pvss_group::<ChunkyTranscript<Bn254>>(&tc, c);
     }
 
     // unweighted aggregatable PVSS
@@ -80,7 +77,7 @@ pub fn ldt_group(c: &mut Criterion) {
 }
 
 pub fn aggregatable_pvss_group<T: AggregatableTranscript + MalleableTranscript>(
-    sc: &T::SecretSharingConfig,
+    sc: &<T as Transcript>::SecretSharingConfig,
     c: &mut Criterion,
 ) -> DealingArgs<T> {
     let name = T::scheme_name();
@@ -104,15 +101,18 @@ pub fn aggregatable_pvss_group<T: AggregatableTranscript + MalleableTranscript>(
 }
 
 // TODO: combine with function above, rather than copy-paste
-pub fn subaggregatable_pvss_group<
-    C: SecretSharingConfig,
-    T: NonAggregatableTranscript
-        + HasAggregatableSubtranscript<C>
-        + MalleableTranscript<SecretSharingConfig = C>,
->(
+pub fn subaggregatable_pvss_group<T>(
     sc: &T::SecretSharingConfig,
     c: &mut Criterion,
-) -> DealingArgs<T> {
+) -> DealingArgs<T>
+where
+    T: MalleableTranscript
+        + HasAggregatableSubtranscript<
+            Subtranscript: Aggregatable<
+                SecretSharingConfig = <T as Transcript>::SecretSharingConfig,
+            >,
+        >,
+{
     let name = T::scheme_name();
     let mut group = c.benchmark_group(format!("pvss/{}", name));
     let mut rng = thread_rng();
@@ -122,7 +122,7 @@ pub fn subaggregatable_pvss_group<
 
     // pvss_transcript_random::<T, WallTime>(sc, &mut group);
     pvss_deal::<T, WallTime>(sc, &d.pp, &d.ssks, &d.spks, &d.eks, &mut group);
-    pvss_subaggregate::<C, T, WallTime>(sc, &mut group);
+    pvss_subaggregate::<T, WallTime>(sc, &mut group);
     pvss_nonaggregate_verify::<T, WallTime>(sc, &d.pp, &d.ssks, &d.spks, &d.eks, &mut group);
     pvss_decrypt_own_share::<T, WallTime>(
         sc, &d.pp, &d.ssks, &d.spks, &d.dks, &d.eks, &d.s, &mut group,
@@ -136,7 +136,7 @@ pub fn subaggregatable_pvss_group<
 pub fn weighted_pvss_group<
     T: AggregatableTranscript + MalleableTranscript<SecretSharingConfig = WeightedConfigBlstrs>,
 >(
-    sc: &T::SecretSharingConfig,
+    sc: &<T as Transcript>::SecretSharingConfig,
     d: DealingArgs<T>,
     c: &mut Criterion,
 ) {
@@ -195,7 +195,7 @@ fn pvss_deal<T: Transcript, M: Measurement>(
 }
 
 fn pvss_aggregate<T: AggregatableTranscript, M: Measurement>(
-    sc: &T::SecretSharingConfig,
+    sc: &<T as Transcript>::SecretSharingConfig,
     g: &mut BenchmarkGroup<M>,
 ) {
     g.throughput(Throughput::Elements(sc.get_total_num_shares() as u64));
@@ -218,14 +218,12 @@ fn pvss_aggregate<T: AggregatableTranscript, M: Measurement>(
     });
 }
 
-fn pvss_subaggregate<
-    C: SecretSharingConfig,
-    T: Transcript<SecretSharingConfig = C> + HasAggregatableSubtranscript<C>,
-    M: Measurement,
->(
-    sc: &T::SecretSharingConfig,
-    g: &mut BenchmarkGroup<M>,
-) {
+fn pvss_subaggregate<T, M: Measurement>(sc: &T::SecretSharingConfig, g: &mut BenchmarkGroup<M>)
+where
+    T: HasAggregatableSubtranscript<
+        Subtranscript: Aggregatable<SecretSharingConfig = <T as Transcript>::SecretSharingConfig>,
+    >,
+{
     g.throughput(Throughput::Elements(sc.get_total_num_shares() as u64));
     let mut rng = thread_rng();
 
@@ -250,7 +248,7 @@ fn pvss_subaggregate<
 }
 
 fn pvss_verify<T: AggregatableTranscript, M: Measurement>(
-    sc: &T::SecretSharingConfig,
+    sc: &<T as Transcript>::SecretSharingConfig,
     pp: &T::PublicParameters,
     ssks: &[T::SigningSecretKey],
     spks: &[T::SigningPubKey],
@@ -285,7 +283,7 @@ fn pvss_verify<T: AggregatableTranscript, M: Measurement>(
     });
 }
 
-fn pvss_nonaggregate_verify<T: NonAggregatableTranscript, M: Measurement>(
+fn pvss_nonaggregate_verify<T: HasAggregatableSubtranscript, M: Measurement>(
     sc: &T::SecretSharingConfig,
     pp: &T::PublicParameters,
     ssks: &[T::SigningSecretKey],
@@ -322,7 +320,7 @@ fn pvss_nonaggregate_verify<T: NonAggregatableTranscript, M: Measurement>(
 }
 
 fn pvss_aggregate_verify<T: AggregatableTranscript + MalleableTranscript, M: Measurement>(
-    sc: &T::SecretSharingConfig,
+    sc: &<T as Transcript>::SecretSharingConfig,
     pp: &T::PublicParameters,
     ssks: &[T::SigningSecretKey],
     spks: &Vec<T::SigningPubKey>,

crates/aptos-dkg/src/pvss/chunky/mod.rs

@@ -23,5 +23,3 @@ pub use weighted_transcript::{
 
 #[allow(type_alias_bounds)]
 pub type SignedWeightedTranscript<E: Pairing> = GenericSigning<UnsignedWeightedTranscript<E>>;
-#[allow(type_alias_bounds)]
-pub type SignedUnweightedTranscript<E: Pairing> = GenericSigning<UnsignedUnweightedTranscript<E>>;