More type replacements

Author: olegnn

bbs_plus/src/proof.rs

@@ -549,7 +549,7 @@ mod tests {
 
     fn sig_setup<R: RngCore>(
         rng: &mut R,
-        message_count: usize,
+        message_count: u32,
     ) -> (
         Vec<Fr>,
         SignatureParamsG1<Bls12_381>,
@@ -976,7 +976,7 @@ mod tests {
         )
         .unwrap();
         let proof_1 = pok_1.gen_proof(&challenge).unwrap();
-        for i in 0..message_count {
+        for i in 0..message_count as usize {
             assert_eq!(
                 *proof_1
                     .get_resp_for_message(i, &revealed_indices_1)
@@ -1089,7 +1089,7 @@ mod tests {
         );
 
         // Reveal one message only
-        for i in 0..message_count {
+        for i in 0..message_count as usize {
             let mut revealed_indices = BTreeSet::new();
             revealed_indices.insert(i);
             let pok = PoKOfSignatureG1Protocol::init(
@@ -1106,7 +1106,7 @@ mod tests {
             )
             .unwrap();
             let proof = pok.gen_proof(&challenge).unwrap();
-            for j in 0..message_count {
+            for j in 0..message_count as usize {
                 if i == j {
                     assert!(proof.get_resp_for_message(j, &revealed_indices).is_err());
                 } else if i < j {

bbs_plus/src/proof_23.rs

@@ -433,7 +433,7 @@ mod tests {
 
     fn sig_setup<R: RngCore>(
         rng: &mut R,
-        message_count: usize,
+        message_count: u32,
     ) -> (
         Vec<Fr>,
         SignatureParams23G1<Bls12_381>,
@@ -739,7 +739,7 @@ mod tests {
         )
         .unwrap();
         let proof_1 = pok_1.gen_proof(&challenge).unwrap();
-        for i in 0..message_count {
+        for i in 0..message_count as usize {
             assert_eq!(
                 *proof_1
                     .get_resp_for_message(i, &revealed_indices_1)
@@ -856,7 +856,7 @@ mod tests {
         );
 
         // Reveal one message only
-        for i in 0..message_count {
+        for i in 0..message_count as usize {
             let mut revealed_indices = BTreeSet::new();
             revealed_indices.insert(i);
             let pok = PoKOfSignature23G1Protocol::init(
@@ -875,7 +875,7 @@ mod tests {
             )
             .unwrap();
             let proof = pok.gen_proof(&challenge).unwrap();
-            for j in 0..message_count {
+            for j in 0..message_count as usize {
                 if i == j {
                     assert!(proof.get_resp_for_message(j, &revealed_indices).is_err());
                 } else if i < j {

bbs_plus/src/proof_23_alternate.rs

@@ -457,7 +457,7 @@ mod tests {
 
     fn sig_setup<R: RngCore>(
         rng: &mut R,
-        message_count: usize,
+        message_count: u32,
     ) -> (
         Vec<Fr>,
         SignatureParams23G1<Bls12_381>,
@@ -515,7 +515,7 @@ mod tests {
         )
         .unwrap();
         let proof_1 = pok_1.gen_proof(&challenge).unwrap();
-        for i in 0..message_count {
+        for i in 0..message_count as usize {
             assert_eq!(
                 *proof_1
                     .get_resp_for_message(i, &revealed_indices_1)
@@ -628,7 +628,7 @@ mod tests {
         );
 
         // Reveal one message only
-        for i in 0..message_count {
+        for i in 0..message_count as usize {
             let mut revealed_indices = BTreeSet::new();
             revealed_indices.insert(i);
             let pok = PoKOfSignature23G1Protocol::init(
@@ -645,7 +645,7 @@ mod tests {
             )
             .unwrap();
             let proof = pok.gen_proof(&challenge).unwrap();
-            for j in 0..message_count {
+            for j in 0..message_count as usize {
                 if i == j {
                     assert!(proof.get_resp_for_message(j, &revealed_indices).is_err());
                 } else if i < j {

bbs_plus/src/setup.rs

@@ -63,6 +63,7 @@ use zeroize::{Zeroize, ZeroizeOnDrop};
 
 use core::iter::once;
 use dock_crypto_utils::{
+    affine_group_from_slices,
     concat_slices, hashing_utils::projective_group_elem_from_try_and_incr, iter::*,
     misc::seq_pairs_satisfy, serde_utils::*, try_iter::CheckLeft,
 };
@@ -244,21 +245,19 @@ macro_rules! impl_sig_params {
             /// Generate params by hashing a known string. The hash function is vulnerable to timing
             /// attack but since all this is public knowledge, it is fine.
             /// This is useful if people need to be convinced that the discrete log of group elements wrt each other is not known.
-            pub fn new<D: Digest>(label: &[u8], message_count: usize) -> Self {
+            pub fn new<D: Digest>(label: &[u8], message_count: u32) -> Self {
                 assert_ne!(message_count, 0);
                 // Need message_count+2 elements of signature group and 1 element of other group
-                let mut sig_group_elems = Vec::with_capacity(message_count + 2);
+                let mut sig_group_elems = Vec::with_capacity(message_count as usize + 2);
                 // Group element by hashing `label`||`g1` as string.
                 let g1 = projective_group_elem_from_try_and_incr::<E::$group_affine, D>(
                     &concat_slices![label, b" : g1"],
                 );
                 // h_0 and h[i] for i in 1 to message_count
                 let mut h = cfg_into_iter!((0..=message_count))
-                    .map(|i| {
-                        projective_group_elem_from_try_and_incr::<E::$group_affine, D>(
-                            &concat_slices![label, b" : h_", (i as u32).to_le_bytes()],
-                        )
-                    })
+                    .map(u32::to_le_bytes)
+                    .map(|i| affine_group_from_slices!(label, b" : h_", i))
+                    .map(E::$group_affine::into)
                     .collect::<Vec<E::$group_projective>>();
                 sig_group_elems.push(g1);
                 sig_group_elems.append(&mut h);
@@ -268,10 +267,8 @@ macro_rules! impl_sig_params {
                 let g1 = sig_group_elems.remove(0);
                 let h_0 = sig_group_elems.remove(0);
 
-                let g2 = projective_group_elem_from_try_and_incr::<E::$other_group_affine, D>(
-                    &concat_slices![label, b" : g2"],
-                )
-                .into_affine();
+                let g2: E::$other_group_affine = affine_group_from_slices!(label, b" : g2");
+
                 Self {
                     g1,
                     g2,
@@ -281,7 +278,7 @@ macro_rules! impl_sig_params {
             }
 
             /// Generate params using a random number generator
-            pub fn generate_using_rng<R>(rng: &mut R, message_count: usize) -> Self
+            pub fn generate_using_rng<R>(rng: &mut R, message_count: u32) -> Self
             where
                 R: RngCore,
             {
@@ -516,7 +513,7 @@ impl<E: Pairing> SignatureParams23G1<E> {
     /// Generate params by hashing a known string. The hash function is vulnerable to timing
     /// attack but since all this is public knowledge, it is fine.
     /// This is useful if people need to be convinced that the discrete log of group elements wrt each other is not known.
-    pub fn new<D: Digest>(label: &[u8], message_count: usize) -> Self {
+    pub fn new<D: Digest>(label: &[u8], message_count: u32) -> Self {
         assert_ne!(message_count, 0);
         // Group element by hashing `label`||`g1` as string.
         let g1 = projective_group_elem_from_try_and_incr::<E::G1Affine, D>(&concat_slices![
@@ -545,7 +542,7 @@ impl<E: Pairing> SignatureParams23G1<E> {
     }
 
     /// Generate params using a random number generator
-    pub fn generate_using_rng<R>(rng: &mut R, message_count: usize) -> Self
+    pub fn generate_using_rng<R>(rng: &mut R, message_count: u32) -> Self
     where
         R: RngCore,
     {
@@ -636,7 +633,7 @@ mod tests {
             let label_1 = "test1".as_bytes();
             let params_1 = $params::<Bls12_381>::new::<Blake2b512>(&label_1, $message_count);
             assert!(params_1.is_valid());
-            assert_eq!(params_1.h.len(), $message_count);
+            assert_eq!(params_1.h.len(), $message_count as usize);
 
             // Same label should generate same params
             let params_1_again = $params::<Bls12_381>::new::<Blake2b512>(&label_1, $message_count);

bbs_plus/src/threshold/cointoss.rs

@@ -40,7 +40,7 @@ impl<F: PrimeField, const SALT_SIZE: usize> Party<F, SALT_SIZE> {
     pub fn commit<R: RngCore>(
         rng: &mut R,
         id: ParticipantId,
-        batch_size: usize,
+        batch_size: u32,
         protocol_id: Vec<u8>,
     ) -> (Self, Commitments) {
         let shares_and_salts = (0..batch_size)
@@ -186,7 +186,7 @@ pub mod tests {
     fn cointoss() {
         let mut rng = StdRng::seed_from_u64(0u64);
 
-        fn check<const SALT_SIZE: usize>(rng: &mut StdRng, batch_size: usize, num_parties: u16) {
+        fn check<const SALT_SIZE: usize>(rng: &mut StdRng, batch_size: u32, num_parties: u16) {
             let label = b"test".to_vec();
             let mut parties = vec![];
             let mut commitments = vec![];

bbs_plus/src/threshold/multiplication_phase.rs

@@ -27,7 +27,7 @@ use oblivious_transfer_protocols::{
 pub struct Phase2<F: PrimeField, const KAPPA: u16, const STATISTICAL_SECURITY_PARAMETER: u16> {
     pub id: ParticipantId,
     /// Number of threshold signatures being generated in a single batch.
-    pub batch_size: u64,
+    pub batch_size: u32,
     /// Transcripts to record protocol interactions with each participant and later used to generate random challenges
     pub transcripts: BTreeMap<ParticipantId, Merlin>,
     pub ote_params: MultiplicationOTEParams<KAPPA, STATISTICAL_SECURITY_PARAMETER>,
@@ -69,7 +69,7 @@ impl<F: PrimeField, const KAPPA: u16, const STATISTICAL_SECURITY_PARAMETER: u16>
         gadget_vector: &GadgetVector<F, KAPPA, STATISTICAL_SECURITY_PARAMETER>,
     ) -> Result<(Self, BTreeMap<ParticipantId, Message1<F>>), BBSPlusError> {
         assert_eq!(masked_signing_key_share.len(), masked_r.len());
-        let batch_size = masked_signing_key_share.len() as u64;
+        let batch_size = masked_signing_key_share.len() as u32;
 
         let mut transcripts = BTreeMap::<ParticipantId, Merlin>::new();
         let mut multiplication_party1 =
@@ -154,7 +154,7 @@ impl<F: PrimeField, const KAPPA: u16, const STATISTICAL_SECURITY_PARAMETER: u16>
 
         let (shares, tau, r, gamma_a) =
             party1.receive::<D>(U, rlc, gamma, trans, &gadget_vector)?;
-        debug_assert_eq!(shares.len() as u64, 2 * self.batch_size);
+        debug_assert_eq!(shares.len() as u32, 2 * self.batch_size);
         let mut z_A_0 = Vec::with_capacity(self.batch_size as usize);
         let mut z_A_1 = Vec::with_capacity(self.batch_size as usize);
         for (i, share) in shares.0.into_iter().enumerate() {
@@ -185,7 +185,7 @@ impl<F: PrimeField, const KAPPA: u16, const STATISTICAL_SECURITY_PARAMETER: u16>
         let party2 = self.multiplication_party2.remove(&sender_id).unwrap();
         let trans = self.transcripts.get_mut(&sender_id).unwrap();
         let shares = party2.receive::<D>(tau, rlc, gamma, trans, &gadget_vector)?;
-        debug_assert_eq!(shares.len() as u64, 2 * self.batch_size);
+        debug_assert_eq!(shares.len() as u32, 2 * self.batch_size);
         let mut z_B_0 = Vec::with_capacity(self.batch_size as usize);
         let mut z_B_1 = Vec::with_capacity(self.batch_size as usize);
         for (i, share) in shares.0.into_iter().enumerate() {

bbs_plus/src/threshold/randomness_generation_phase.rs

@@ -14,7 +14,7 @@ use oblivious_transfer_protocols::ParticipantId;
 pub struct Phase1<F: PrimeField, const SALT_SIZE: usize> {
     pub id: ParticipantId,
     /// Number of threshold signatures being generated in a single batch.
-    pub batch_size: u64,
+    pub batch_size: u32,
     pub r: Vec<F>,
     /// Protocols to generate shares of random values used in signature like `e`
     pub commitment_protocol: super::cointoss::Party<F, SALT_SIZE>,

bbs_plus/src/threshold/threshold_bbs.rs

@@ -24,7 +24,7 @@ use oblivious_transfer_protocols::ParticipantId;
 #[derive(Clone, Debug, PartialEq, CanonicalSerialize, CanonicalDeserialize)]
 pub struct Phase1Output<F: PrimeField> {
     pub id: ParticipantId,
-    pub batch_size: u64,
+    pub batch_size: u32,
     pub r: Vec<F>,
     pub e: Vec<F>,
     /// Additive shares of the signing key masked by a random `alpha`
@@ -47,7 +47,7 @@ pub struct BBSSignatureShare<E: Pairing> {
 impl<F: PrimeField, const SALT_SIZE: usize> Phase1<F, SALT_SIZE> {
     pub fn init_for_bbs<R: RngCore>(
         rng: &mut R,
-        batch_size: usize,
+        batch_size: u32,
         id: ParticipantId,
         others: BTreeSet<ParticipantId>,
         protocol_id: Vec<u8>,
@@ -65,7 +65,7 @@ impl<F: PrimeField, const SALT_SIZE: usize> Phase1<F, SALT_SIZE> {
         Ok((
             Self {
                 id,
-                batch_size: batch_size as u64,
+                batch_size: batch_size,
                 r,
                 commitment_protocol,
                 zero_sharing_protocol,
@@ -86,7 +86,7 @@ impl<F: PrimeField, const SALT_SIZE: usize> Phase1<F, SALT_SIZE> {
         let r = self.r.clone();
         let (others, randomness, masked_signing_key_share, masked_r) =
             self.compute_randomness_and_arguments_for_multiplication::<D>(signing_key)?;
-        debug_assert_eq!(randomness.len() as u64, batch_size);
+        debug_assert_eq!(randomness.len() as u32, batch_size);
         let e = randomness;
         Ok(Phase1Output {
             id,
@@ -307,7 +307,7 @@ pub mod tests {
         }
         println!("Phase 1 took {:?}", start.elapsed());
 
-        assert_eq!(expected_sk, sk * Fr::from(sig_batch_size as u64));
+        assert_eq!(expected_sk, sk * Fr::from(sig_batch_size));
         for i in 1..threshold_signers {
             assert_eq!(round1outs[0].e, round1outs[i as usize].e);
         }

bbs_plus/src/threshold/threshold_bbs_plus.rs

@@ -25,7 +25,7 @@ use super::{multiplication_phase::Phase2Output, utils::compute_R_and_u};
 #[derive(Clone, Debug, PartialEq, CanonicalSerialize, CanonicalDeserialize)]
 pub struct Phase1Output<F: PrimeField> {
     pub id: ParticipantId,
-    pub batch_size: u64,
+    pub batch_size: u32,
     pub r: Vec<F>,
     pub e: Vec<F>,
     pub s: Vec<F>,
@@ -50,7 +50,7 @@ pub struct BBSPlusSignatureShare<E: Pairing> {
 impl<F: PrimeField, const SALT_SIZE: usize> Phase1<F, SALT_SIZE> {
     pub fn init_for_bbs_plus<R: RngCore>(
         rng: &mut R,
-        batch_size: usize,
+        batch_size: u32,
         id: ParticipantId,
         others: BTreeSet<ParticipantId>,
         protocol_id: Vec<u8>,
@@ -68,7 +68,7 @@ impl<F: PrimeField, const SALT_SIZE: usize> Phase1<F, SALT_SIZE> {
         Ok((
             Self {
                 id,
-                batch_size: batch_size as u64,
+                batch_size: batch_size,
                 r,
                 commitment_protocol,
                 zero_sharing_protocol,
@@ -89,7 +89,7 @@ impl<F: PrimeField, const SALT_SIZE: usize> Phase1<F, SALT_SIZE> {
         let r = self.r.clone();
         let (others, mut randomness, masked_signing_key_shares, masked_rs) =
             self.compute_randomness_and_arguments_for_multiplication::<D>(signing_key)?;
-        debug_assert_eq!(randomness.len() as u64, 2 * batch_size);
+        debug_assert_eq!(randomness.len() as u32, 2 * batch_size);
         let e = randomness.drain(0..batch_size as usize).collect();
         let s = randomness;
         Ok(Phase1Output {
@@ -248,8 +248,8 @@ pub mod tests {
             ote_params: MultiplicationOTEParams<KAPPA, STATISTICAL_SECURITY_PARAMETER>,
             threshold_signers: u16,
             total_signers: u16,
-            sig_batch_size: usize,
-            message_count: usize,
+            sig_batch_size: u32,
+            message_count: u32,
             gadget_vector: &GadgetVector<Fr, KAPPA, STATISTICAL_SECURITY_PARAMETER>,
         ) {
             let protocol_id = b"test".to_vec();
@@ -351,7 +351,7 @@ pub mod tests {
             total_phase1_time = start.elapsed();
             println!("Phase 1 took {:?}", total_phase1_time);
 
-            assert_eq!(expected_sk, sk * Fr::from(sig_batch_size as u64));
+            assert_eq!(expected_sk, sk * Fr::from(sig_batch_size));
             for i in 1..threshold_signers {
                 assert_eq!(round1outs[0].e, round1outs[i as usize].e);
                 assert_eq!(round1outs[0].s, round1outs[i as usize].s);

bbs_plus/src/threshold/zero_sharing.rs

@@ -23,7 +23,7 @@ use oblivious_transfer_protocols::ParticipantId;
 pub struct Party<F: PrimeField, const SALT_SIZE: usize> {
     pub id: ParticipantId,
     pub protocol_id: Vec<u8>,
-    pub batch_size: u64,
+    pub batch_size: u32,
     /// Commit-and-release coin tossing protocols run with each party
     pub cointoss_protocols: BTreeMap<ParticipantId, CommitmentParty<F, SALT_SIZE>>,
 }
@@ -36,7 +36,7 @@ impl<F: PrimeField, const SALT_SIZE: usize> Party<F, SALT_SIZE> {
     pub fn init<R: RngCore>(
         rng: &mut R,
         id: ParticipantId,
-        batch_size: usize,
+        batch_size: u32,
         others: BTreeSet<ParticipantId>,
         protocol_id: Vec<u8>,
     ) -> (Self, BTreeMap<ParticipantId, Commitments>) {
@@ -52,7 +52,7 @@ impl<F: PrimeField, const SALT_SIZE: usize> Party<F, SALT_SIZE> {
             Self {
                 id,
                 protocol_id,
-                batch_size: batch_size as u64,
+                batch_size: batch_size,
                 cointoss_protocols,
             },
             commitments,
@@ -174,7 +174,7 @@ pub mod tests {
     fn zero_sharing() {
         let mut rng = StdRng::seed_from_u64(0u64);
 
-        fn check(rng: &mut StdRng, batch_size: usize, num_parties: u16) {
+        fn check(rng: &mut StdRng, batch_size: u32, num_parties: u16) {
             let protocol_id = b"test".to_vec();
             let all_party_set = (1..=num_parties).into_iter().collect::<BTreeSet<_>>();
             let mut parties = vec![];