diff --git a/src/vdaf/prio3.rs b/src/vdaf/prio3.rs index 087729d63..ee0e5c1e7 100644 --- a/src/vdaf/prio3.rs +++ b/src/vdaf/prio3.rs @@ -77,7 +77,7 @@ pub type Prio3Count = Prio3, XofTurboShake128, 16>; impl Prio3Count { /// Construct an instance of Prio3Count with the given number of aggregators. pub fn new_count(num_aggregators: u8) -> Result { - Prio3::new(num_aggregators, Count::new()) + Prio3::new(num_aggregators, 1, Count::new()) } } @@ -96,7 +96,7 @@ impl Prio3SumVec { len: usize, chunk_length: usize, ) -> Result { - Prio3::new(num_aggregators, SumVec::new(bits, len, chunk_length)?) + Prio3::new(num_aggregators, 1, SumVec::new(bits, len, chunk_length)?) } } @@ -121,7 +121,7 @@ impl Prio3SumVecMultithreaded { len: usize, chunk_length: usize, ) -> Result { - Prio3::new(num_aggregators, SumVec::new(bits, len, chunk_length)?) + Prio3::new(num_aggregators, 1, SumVec::new(bits, len, chunk_length)?) } } @@ -139,7 +139,7 @@ impl Prio3Sum { ))); } - Prio3::new(num_aggregators, Sum::new(bits)?) + Prio3::new(num_aggregators, 1, Sum::new(bits)?) } } @@ -176,7 +176,7 @@ impl Prio3FixedPointBoundedL2VecSum { entries: usize, ) -> Result { check_num_aggregators(num_aggregators)?; - Prio3::new(num_aggregators, FixedPointBoundedL2VecSum::new(entries)?) + Prio3::new(num_aggregators, 1, FixedPointBoundedL2VecSum::new(entries)?) } } @@ -207,7 +207,7 @@ impl Prio3FixedPointBoundedL2VecSumMultithreaded Result { check_num_aggregators(num_aggregators)?; - Prio3::new(num_aggregators, FixedPointBoundedL2VecSum::new(entries)?) + Prio3::new(num_aggregators, 1, FixedPointBoundedL2VecSum::new(entries)?) } } @@ -224,7 +224,7 @@ impl Prio3Histogram { length: usize, chunk_length: usize, ) -> Result { - Prio3::new(num_aggregators, Histogram::new(length, chunk_length)?) + Prio3::new(num_aggregators, 1, Histogram::new(length, chunk_length)?) } } @@ -247,7 +247,7 @@ impl Prio3HistogramMultithreaded { length: usize, chunk_length: usize, ) -> Result { - Prio3::new(num_aggregators, Histogram::new(length, chunk_length)?) + Prio3::new(num_aggregators, 1, Histogram::new(length, chunk_length)?) } } @@ -269,6 +269,7 @@ impl Prio3Average { Ok(Prio3 { num_aggregators, + num_proofs: 1, typ: Average::new(bits)?, phantom: PhantomData, }) @@ -345,6 +346,7 @@ where P: Xof, { num_aggregators: u8, + num_proofs: u8, typ: T, phantom: PhantomData

, } @@ -354,12 +356,19 @@ where T: Type, P: Xof, { - /// Construct an instance of this Prio3 VDAF with the given number of aggregators and the - /// underlying type. - pub fn new(num_aggregators: u8, typ: T) -> Result { + /// Construct an instance of this Prio3 VDAF with the given number of aggregators, number of + /// proofs to generate and verify, and the underlying type. + pub fn new(num_aggregators: u8, num_proofs: u8, typ: T) -> Result { check_num_aggregators(num_aggregators)?; + if num_proofs == 0 { + return Err(VdafError::Uncategorized( + "num_proofs must be at least 1".to_string(), + )); + } + Ok(Self { num_aggregators, + num_proofs, typ, phantom: PhantomData, }) @@ -375,19 +384,72 @@ where self.typ.verifier_len() } + #[inline] + fn num_proofs(&self) -> usize { + self.num_proofs.into() + } + + fn derive_prove_rands(&self, prove_rand_seed: &Seed) -> Vec { + P::seed_stream( + prove_rand_seed, + &Self::domain_separation_tag(DST_PROVE_RANDOMNESS), + &[self.num_proofs], + ) + .into_field_vec(self.typ.prove_rand_len() * self.num_proofs()) + } + fn derive_joint_rand_seed<'a>( - parts: impl Iterator>, + &self, + joint_rand_parts: impl Iterator>, ) -> Seed { let mut xof = P::init( &[0; SEED_SIZE], &Self::domain_separation_tag(DST_JOINT_RAND_SEED), ); - for part in parts { + for part in joint_rand_parts { xof.update(part.as_ref()); } xof.into_seed() } + fn derive_joint_rands<'a>( + &self, + joint_rand_parts: impl Iterator>, + ) -> (Seed, Vec) { + let joint_rand_seed = self.derive_joint_rand_seed(joint_rand_parts); + let joint_rands = P::seed_stream( + &joint_rand_seed, + &Self::domain_separation_tag(DST_JOINT_RANDOMNESS), + &[self.num_proofs], + ) + .into_field_vec(self.typ.joint_rand_len() * self.num_proofs()); + + (joint_rand_seed, joint_rands) + } + + fn derive_helper_proofs_share( + &self, + proofs_share_seed: &Seed, + agg_id: u8, + ) -> Prng { + Prng::from_seed_stream(P::seed_stream( + proofs_share_seed, + &Self::domain_separation_tag(DST_PROOF_SHARE), + &[self.num_proofs, agg_id], + )) + } + + fn derive_query_rands(&self, verify_key: &[u8; SEED_SIZE], nonce: &[u8; 16]) -> Vec { + let mut xof = P::init( + verify_key, + &Self::domain_separation_tag(DST_QUERY_RANDOMNESS), + ); + xof.update(&[self.num_proofs]); + xof.update(nonce); + xof.into_seed_stream() + .into_field_vec(self.typ.query_rand_len() * self.num_proofs()) + } + fn random_size(&self) -> usize { if self.typ.joint_rand_len() == 0 { // Two seeds per helper for measurement and proof shares, plus one seed for proving @@ -517,43 +579,40 @@ where }; // Compute the joint randomness. - let joint_rand: Vec = public_share + let joint_rands = public_share .joint_rand_parts .as_ref() - .map(|joint_rand_parts| { - let joint_rand_seed = Self::derive_joint_rand_seed(joint_rand_parts.iter()); - P::seed_stream( - &joint_rand_seed, - &Self::domain_separation_tag(DST_JOINT_RANDOMNESS), - &[], - ) - .into_field_vec(self.typ.joint_rand_len()) - }) + .map(|joint_rand_parts| self.derive_joint_rands(joint_rand_parts.iter()).1) .unwrap_or_default(); - // Run the proof-generation algorithm. - let prove_rand_seed = random_seeds.next().unwrap().try_into().unwrap(); - let prove_rand = P::seed_stream( - &Seed::from_bytes(prove_rand_seed), - &Self::domain_separation_tag(DST_PROVE_RANDOMNESS), - &[], - ) - .into_field_vec(self.typ.prove_rand_len()); - let mut leader_proof_share = - self.typ - .prove(&encoded_measurement, &prove_rand, &joint_rand)?; + // Generate the proofs. + let prove_rands = self.derive_prove_rands(&Seed::from_bytes( + random_seeds.next().unwrap().try_into().unwrap(), + )); + let mut leader_proofs_share = Vec::with_capacity(self.typ.proof_len() * self.num_proofs()); + for p in 0..self.num_proofs() { + let prove_rand = + &prove_rands[p * self.typ.prove_rand_len()..(p + 1) * self.typ.prove_rand_len()]; + let joint_rand = + &joint_rands[p * self.typ.joint_rand_len()..(p + 1) * self.typ.joint_rand_len()]; + + leader_proofs_share.append(&mut self.typ.prove( + &encoded_measurement, + prove_rand, + joint_rand, + )?); + } // Generate the proof shares and distribute the joint randomness seed hints. for (j, helper) in helper_shares.iter_mut().enumerate() { - let proof_share_prng: Prng = Prng::from_seed_stream(P::seed_stream( - &helper.proof_share, - &Self::domain_separation_tag(DST_PROOF_SHARE), - &[j as u8 + 1], - )); - for (x, y) in leader_proof_share - .iter_mut() - .zip(proof_share_prng) - .take(self.typ.proof_len()) + for (x, y) in + leader_proofs_share + .iter_mut() + .zip(self.derive_helper_proofs_share( + &helper.proofs_share, + u8::try_from(j).unwrap() + 1, + )) + .take(self.typ.proof_len() * self.num_proofs()) { *x -= y; } @@ -563,14 +622,14 @@ where let mut out = Vec::with_capacity(num_aggregators as usize); out.push(Prio3InputShare { measurement_share: Share::Leader(leader_measurement_share), - proof_share: Share::Leader(leader_proof_share), + proofs_share: Share::Leader(leader_proofs_share), joint_rand_blind: leader_blind_opt, }); for helper in helper_shares.into_iter() { out.push(Prio3InputShare { measurement_share: Share::Helper(helper.measurement_share), - proof_share: Share::Helper(helper.proof_share), + proofs_share: Share::Helper(helper.proofs_share), joint_rand_blind: helper.joint_rand_blind, }); } @@ -681,7 +740,7 @@ pub struct Prio3InputShare { measurement_share: Share, /// The proof share. - proof_share: Share, + proofs_share: Share, /// Blinding seed used by the Aggregator to compute the joint randomness. This field is optional /// because not every [`Type`] requires joint randomness. @@ -703,28 +762,28 @@ impl ConstantTimeEq for Prio3InputSha self.joint_rand_blind.as_ref(), other.joint_rand_blind.as_ref(), ) & self.measurement_share.ct_eq(&other.measurement_share) - & self.proof_share.ct_eq(&other.proof_share) + & self.proofs_share.ct_eq(&other.proofs_share) } } impl Encode for Prio3InputShare { fn encode(&self, bytes: &mut Vec) { if matches!( - (&self.measurement_share, &self.proof_share), + (&self.measurement_share, &self.proofs_share), (Share::Leader(_), Share::Helper(_)) | (Share::Helper(_), Share::Leader(_)) ) { panic!("tried to encode input share with ambiguous encoding") } self.measurement_share.encode(bytes); - self.proof_share.encode(bytes); + self.proofs_share.encode(bytes); if let Some(ref blind) = self.joint_rand_blind { blind.encode(bytes); } } fn encoded_len(&self) -> Option { - let mut len = self.measurement_share.encoded_len()? + self.proof_share.encoded_len()?; + let mut len = self.measurement_share.encoded_len()? + self.proofs_share.encoded_len()?; if let Some(ref blind) = self.joint_rand_blind { len += blind.encoded_len()?; } @@ -748,7 +807,7 @@ where let (input_decoder, proof_decoder) = if agg_id == 0 { ( ShareDecodingParameter::Leader(prio3.typ.input_len()), - ShareDecodingParameter::Leader(prio3.typ.proof_len()), + ShareDecodingParameter::Leader(prio3.typ.proof_len() * prio3.num_proofs()), ) } else { ( @@ -758,7 +817,7 @@ where }; let measurement_share = Share::decode_with_param(&input_decoder, bytes)?; - let proof_share = Share::decode_with_param(&proof_decoder, bytes)?; + let proofs_share = Share::decode_with_param(&proof_decoder, bytes)?; let joint_rand_blind = if prio3.typ.joint_rand_len() > 0 { let blind = Seed::decode(bytes)?; Some(blind) @@ -768,7 +827,7 @@ where Ok(Prio3InputShare { measurement_share, - proof_share, + proofs_share, joint_rand_blind, }) } @@ -778,7 +837,7 @@ where /// Message broadcast by each [`Aggregator`] in each round of the Preparation phase. pub struct Prio3PrepareShare { /// A share of the FLP verifier message. (See [`Type`].) - verifier: Vec, + verifiers: Vec, /// A part of the joint randomness seed. joint_rand_part: Option>, @@ -798,7 +857,7 @@ impl ConstantTimeEq for Prio3PrepareS option_ct_eq( self.joint_rand_part.as_ref(), other.joint_rand_part.as_ref(), - ) & self.verifier.ct_eq(&other.verifier) + ) & self.verifiers.ct_eq(&other.verifiers) } } @@ -806,7 +865,7 @@ impl Encode for Prio3PrepareShare { fn encode(&self, bytes: &mut Vec) { - for x in &self.verifier { + for x in &self.verifiers { x.encode(bytes); } if let Some(ref seed) = self.joint_rand_part { @@ -816,7 +875,7 @@ impl Encode fn encoded_len(&self) -> Option { // Each element of the verifier has the same size. - let mut len = F::ENCODED_SIZE * self.verifier.len(); + let mut len = F::ENCODED_SIZE * self.verifiers.len(); if let Some(ref seed) = self.joint_rand_part { len += seed.encoded_len()?; } @@ -831,9 +890,9 @@ impl decoding_parameter: &Prio3PrepareState, bytes: &mut Cursor<&[u8]>, ) -> Result { - let mut verifier = Vec::with_capacity(decoding_parameter.verifier_len); - for _ in 0..decoding_parameter.verifier_len { - verifier.push(F::decode(bytes)?); + let mut verifiers = Vec::with_capacity(decoding_parameter.verifiers_len); + for _ in 0..decoding_parameter.verifiers_len { + verifiers.push(F::decode(bytes)?); } let joint_rand_part = if decoding_parameter.joint_rand_seed.is_some() { @@ -843,7 +902,7 @@ impl }; Ok(Prio3PrepareShare { - verifier, + verifiers, joint_rand_part, }) } @@ -930,7 +989,7 @@ pub struct Prio3PrepareState { measurement_share: Share, joint_rand_seed: Option>, agg_id: u8, - verifier_len: usize, + verifiers_len: usize, } impl PartialEq for Prio3PrepareState { @@ -945,7 +1004,7 @@ impl ConstantTimeEq for Prio3PrepareS fn ct_eq(&self, other: &Self) -> Choice { // We allow short-circuiting on the presence or absence of the joint_rand_seed, as well as // the aggregator ID & verifier length parameters. - if self.agg_id != other.agg_id || self.verifier_len != other.verifier_len { + if self.agg_id != other.agg_id || self.verifiers_len != other.verifiers_len { return Choice::from(0); } @@ -968,7 +1027,7 @@ impl Debug for Prio3PrepareState { }, ) .field("agg_id", &self.agg_id) - .field("verifier_len", &self.verifier_len) + .field("verifiers_len", &self.verifiers_len) .finish() } } @@ -1024,7 +1083,7 @@ where measurement_share, joint_rand_seed, agg_id, - verifier_len: prio3.typ.verifier_len(), + verifiers_len: prio3.typ.verifier_len() * prio3.num_proofs(), }) } } @@ -1057,14 +1116,6 @@ where VdafError, > { let agg_id = self.role_try_from(agg_id)?; - let mut query_rand_xof = P::init( - verify_key, - &Self::domain_separation_tag(DST_QUERY_RANDOMNESS), - ); - query_rand_xof.update(nonce); - let query_rand = query_rand_xof - .into_seed_stream() - .into_field_vec(self.typ.query_rand_len()); // Create a reference to the (expanded) measurement share. let expanded_measurement_share: Option> = match msg.measurement_share { @@ -1084,24 +1135,21 @@ where }; // Create a reference to the (expanded) proof share. - let expanded_proof_share: Option> = match msg.proof_share { + let expanded_proofs_share: Option> = match msg.proofs_share { Share::Leader(_) => None, - Share::Helper(ref seed) => Some( - P::seed_stream( - seed, - &Self::domain_separation_tag(DST_PROOF_SHARE), - &[agg_id], - ) - .into_field_vec(self.typ.proof_len()), + Share::Helper(ref proof_shares_seed) => Some( + self.derive_helper_proofs_share(proof_shares_seed, agg_id) + .take(self.typ.proof_len() * self.num_proofs()) + .collect(), ), }; - let proof_share = match msg.proof_share { + let proofs_share = match msg.proofs_share { Share::Leader(ref data) => data, - Share::Helper(_) => expanded_proof_share.as_ref().unwrap(), + Share::Helper(_) => expanded_proofs_share.as_ref().unwrap(), }; // Compute the joint randomness. - let (joint_rand_seed, joint_rand_part, joint_rand) = if self.typ.joint_rand_len() > 0 { + let (joint_rand_seed, joint_rand_part, joint_rands) = if self.typ.joint_rand_len() > 0 { let mut joint_rand_part_xof = P::init( msg.joint_rand_blind.as_ref().unwrap().as_ref(), &Self::domain_separation_tag(DST_JOINT_RAND_PART), @@ -1137,37 +1185,47 @@ where .skip(agg_id as usize + 1), ); - let joint_rand_seed = Self::derive_joint_rand_seed(corrected_joint_rand_parts); + let (joint_rand_seed, joint_rands) = + self.derive_joint_rands(corrected_joint_rand_parts); - let joint_rand = P::seed_stream( - &joint_rand_seed, - &Self::domain_separation_tag(DST_JOINT_RANDOMNESS), - &[], + ( + Some(joint_rand_seed), + Some(own_joint_rand_part), + joint_rands, ) - .into_field_vec(self.typ.joint_rand_len()); - (Some(joint_rand_seed), Some(own_joint_rand_part), joint_rand) } else { (None, None, Vec::new()) }; // Run the query-generation algorithm. - let verifier_share = self.typ.query( - measurement_share, - proof_share, - &query_rand, - &joint_rand, - self.num_aggregators as usize, - )?; + let query_rands = self.derive_query_rands(verify_key, nonce); + let mut verifiers_share = Vec::with_capacity(self.typ.verifier_len() * self.num_proofs()); + for p in 0..self.num_proofs() { + let query_rand = + &query_rands[p * self.typ.query_rand_len()..(p + 1) * self.typ.query_rand_len()]; + let joint_rand = + &joint_rands[p * self.typ.joint_rand_len()..(p + 1) * self.typ.joint_rand_len()]; + let proof_share = + &proofs_share[p * self.typ.proof_len()..(p + 1) * self.typ.proof_len()]; + + verifiers_share.append(&mut self.typ.query( + measurement_share, + proof_share, + query_rand, + joint_rand, + self.num_aggregators as usize, + )?); + } Ok(( Prio3PrepareState { measurement_share: msg.measurement_share.clone(), joint_rand_seed, agg_id, - verifier_len: verifier_share.len(), + verifiers_len: verifiers_share.len(), }, Prio3PrepareShare { - verifier: verifier_share, + verifiers: verifiers_share, joint_rand_part, }, )) @@ -1180,17 +1238,17 @@ where _: &Self::AggregationParam, inputs: M, ) -> Result, VdafError> { - let mut verifier = vec![T::Field::zero(); self.typ.verifier_len()]; + let mut verifiers = vec![T::Field::zero(); self.typ.verifier_len() * self.num_proofs()]; let mut joint_rand_parts = Vec::with_capacity(self.num_aggregators()); let mut count = 0; for share in inputs.into_iter() { count += 1; - if share.verifier.len() != verifier.len() { + if share.verifiers.len() != verifiers.len() { return Err(VdafError::Uncategorized(format!( "unexpected verifier share length: got {}; want {}", - share.verifier.len(), - verifier.len(), + share.verifiers.len(), + verifiers.len(), ))); } @@ -1199,7 +1257,7 @@ where joint_rand_parts.push(joint_rand_seed_part); } - for (x, y) in verifier.iter_mut().zip(share.verifier) { + for (x, y) in verifiers.iter_mut().zip(share.verifiers) { *x += y; } } @@ -1211,19 +1269,17 @@ where ))); } - // Check the proof verifier. - match self.typ.decide(&verifier) { - Ok(true) => (), - Ok(false) => { + // Check the proof verifiers. + for verifier in verifiers.chunks(self.typ.verifier_len()) { + if !self.typ.decide(verifier)? { return Err(VdafError::Uncategorized( "proof verifier check failed".into(), - )) + )); } - Err(err) => return Err(VdafError::from(err)), - }; + } let joint_rand_seed = if self.typ.joint_rand_len() > 0 { - Some(Self::derive_joint_rand_seed(joint_rand_parts.iter())) + Some(self.derive_joint_rand_seed(joint_rand_parts.iter())) } else { None }; @@ -1330,7 +1386,7 @@ where #[derive(Clone)] struct HelperShare { measurement_share: Seed, - proof_share: Seed, + proofs_share: Seed, joint_rand_blind: Option>, } @@ -1342,7 +1398,7 @@ impl HelperShare { ) -> Self { HelperShare { measurement_share: Seed::from_bytes(measurement_share), - proof_share: Seed::from_bytes(proof_share), + proofs_share: Seed::from_bytes(proof_share), joint_rand_blind: joint_rand_blind.map(Seed::from_bytes), } } @@ -1528,7 +1584,7 @@ mod tests { assert_matches!(result, Err(VdafError::Uncategorized(_))); let (public_share, mut input_shares) = prio3.shard(&1, &nonce).unwrap(); - assert_matches!(input_shares[0].proof_share, Share::Leader(ref mut data) => { + assert_matches!(input_shares[0].proofs_share, Share::Leader(ref mut data) => { data[0] += Field128::one(); }); let result = run_vdaf_prepare(&prio3, &verify_key, &(), &nonce, public_share, input_shares); @@ -1555,6 +1611,30 @@ mod tests { ); } + #[test] + fn test_prio3_sum_vec_multiproof() { + let prio3 = Prio3::< + SumVec>>, + XofTurboShake128, + 16, + >::new(2, 2, SumVec::new(2, 20, 4).unwrap()) + .unwrap(); + + assert_eq!( + run_vdaf( + &prio3, + &(), + [ + vec![0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1], + vec![0, 2, 0, 0, 1, 0, 0, 0, 1, 1, 1, 3, 0, 3, 0, 0, 0, 1, 0, 0], + vec![1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1], + ] + ) + .unwrap(), + vec![1, 3, 1, 0, 3, 1, 0, 1, 2, 2, 3, 3, 1, 5, 1, 2, 1, 3, 0, 2], + ); + } + #[test] #[cfg(feature = "multithreaded")] fn test_prio3_sum_vec_multithreaded() { @@ -1758,7 +1838,7 @@ mod tests { let (public_share, mut input_shares) = prio3 .shard(&vec![fp_4_inv, fp_8_inv, fp_16_inv], &nonce) .unwrap(); - assert_matches!(input_shares[0].proof_share, Share::Leader(ref mut data) => { + assert_matches!(input_shares[0].proofs_share, Share::Leader(ref mut data) => { data[0] += Field128::one(); }); let result = @@ -1829,7 +1909,7 @@ mod tests { } if let (Share::Helper(left), Share::Helper(right)) = - (&x.proof_share, &y.proof_share) + (&x.proofs_share, &y.proofs_share) { assert_ne!(left, right); } @@ -1973,31 +2053,31 @@ mod tests { // Default. Prio3InputShare { measurement_share: Share::Leader(Vec::from([0])), - proof_share: Share::Leader(Vec::from([1])), + proofs_share: Share::Leader(Vec::from([1])), joint_rand_blind: Some(Seed([2])), }, // Modified measurement share. Prio3InputShare { measurement_share: Share::Leader(Vec::from([100])), - proof_share: Share::Leader(Vec::from([1])), + proofs_share: Share::Leader(Vec::from([1])), joint_rand_blind: Some(Seed([2])), }, // Modified proof share. Prio3InputShare { measurement_share: Share::Leader(Vec::from([0])), - proof_share: Share::Leader(Vec::from([101])), + proofs_share: Share::Leader(Vec::from([101])), joint_rand_blind: Some(Seed([2])), }, // Modified joint_rand_blind. Prio3InputShare { measurement_share: Share::Leader(Vec::from([0])), - proof_share: Share::Leader(Vec::from([1])), + proofs_share: Share::Leader(Vec::from([1])), joint_rand_blind: Some(Seed([102])), }, // Missing joint_rand_blind. Prio3InputShare { measurement_share: Share::Leader(Vec::from([0])), - proof_share: Share::Leader(Vec::from([1])), + proofs_share: Share::Leader(Vec::from([1])), joint_rand_blind: None, }, ]) @@ -2008,22 +2088,22 @@ mod tests { equality_comparison_test(&[ // Default. Prio3PrepareShare { - verifier: Vec::from([0]), + verifiers: Vec::from([0]), joint_rand_part: Some(Seed([1])), }, // Modified verifier. Prio3PrepareShare { - verifier: Vec::from([100]), + verifiers: Vec::from([100]), joint_rand_part: Some(Seed([1])), }, // Modified joint_rand_part. Prio3PrepareShare { - verifier: Vec::from([0]), + verifiers: Vec::from([0]), joint_rand_part: Some(Seed([101])), }, // Missing joint_rand_part. Prio3PrepareShare { - verifier: Vec::from([0]), + verifiers: Vec::from([0]), joint_rand_part: None, }, ]) @@ -2055,42 +2135,42 @@ mod tests { measurement_share: Share::Leader(Vec::from([0])), joint_rand_seed: Some(Seed([1])), agg_id: 2, - verifier_len: 3, + verifiers_len: 3, }, // Modified measurement share. Prio3PrepareState { measurement_share: Share::Leader(Vec::from([100])), joint_rand_seed: Some(Seed([1])), agg_id: 2, - verifier_len: 3, + verifiers_len: 3, }, // Modified joint_rand_seed. Prio3PrepareState { measurement_share: Share::Leader(Vec::from([0])), joint_rand_seed: Some(Seed([101])), agg_id: 2, - verifier_len: 3, + verifiers_len: 3, }, // Missing joint_rand_seed. Prio3PrepareState { measurement_share: Share::Leader(Vec::from([0])), joint_rand_seed: None, agg_id: 2, - verifier_len: 3, + verifiers_len: 3, }, // Modified agg_id. Prio3PrepareState { measurement_share: Share::Leader(Vec::from([0])), joint_rand_seed: Some(Seed([1])), agg_id: 102, - verifier_len: 3, + verifiers_len: 3, }, // Modified verifier_len. Prio3PrepareState { measurement_share: Share::Leader(Vec::from([0])), joint_rand_seed: Some(Seed([1])), agg_id: 2, - verifier_len: 103, + verifiers_len: 103, }, ]) }