address vit-2568, remove panic on babysteps if max_value = 0 (#750)

* address vit-2568, remove panic on babysteps if max_value = 0

* refactor decrypt_tally to use NonZeroU64 where possible

* remove decrypt strategy enum, provide len func

* create TallyDecryptor struct

* fix formatting

* add batch_decrypt, still todo on from_bytes implementation

* working batch_decrypt

* working batch_decrypt

* fix serialization sanity test

* add batch decrypt tests

* PR feedback, remove unnecessary non-zero bounds, ...

* remove max_votes from `decrypt_tally`, remove redundant test

* remove unnecessary unwrap()

Author: cameron1024

chain-impl-mockchain/benches/tally.rs

@@ -63,7 +63,7 @@ fn tally_benchmark(
         .sample_iter(&mut rng)
         .take(voters_count)
         .collect();
-    let total_votes = voting_powers.iter().sum();
+    let total_votes: u64 = voting_powers.iter().sum();
     let token_name: TokenName = vec![0u8; TOKEN_NAME_MAX_SIZE].try_into().unwrap();
     let mut voters_wallets: Vec<_> = voters_aliases
         .iter()
@@ -233,7 +233,7 @@ fn tally_benchmark(
         .collect();
 
     let decrypt_tally = || {
-        let table = chain_vote::TallyOptimizationTable::generate(total_votes);
+        let table = chain_vote::TallyOptimizationTable::generate(total_votes.try_into().unwrap());
 
         vote_plan_status
             .proposals
@@ -252,7 +252,7 @@ fn tally_benchmark(
                         &decrypt_shares[i],
                     )
                     .unwrap()
-                    .decrypt_tally(total_votes_per_proposal[i], &table)
+                    .decrypt_tally(&table)
                     .unwrap()
             })
             .collect::<Vec<_>>()

chain-impl-mockchain/src/testing/builders/vote.rs

@@ -6,39 +6,25 @@ use crate::{
     vote::VotePlanStatus,
 };
 
+use chain_vote::tally::batch_decrypt;
 use rand::thread_rng;
 
 pub fn decrypt_tally(
     vote_plan_status: &VotePlanStatus,
     members: &CommitteeMembersManager,
 ) -> Result<DecryptedPrivateTally, DecryptedPrivateTallyError> {
-    let encrypted_tally = vote_plan_status
-        .proposals
-        .iter()
-        .map(|proposal| {
-            let tally_state = proposal.tally.as_ref().unwrap();
-            let encrypted_tally = tally_state.private_encrypted().unwrap().0.clone();
-            let max_votes = tally_state.private_total_power().unwrap();
-            (encrypted_tally, max_votes)
-        })
-        .collect::<Vec<_>>();
-
-    let absolute_max_votes = encrypted_tally
-        .iter()
-        .map(|(_encrypted_tally, max_votes)| *max_votes)
-        .max()
-        .unwrap();
-    let table = chain_vote::TallyOptimizationTable::generate_with_balance(absolute_max_votes, 1);
-
     let members_pks: Vec<chain_vote::MemberPublicKey> = members
         .members()
         .iter()
         .map(|member| member.public_key())
         .collect();
 
-    let proposals = encrypted_tally
-        .into_iter()
-        .map(|(encrypted_tally, max_votes)| {
+    let (shares, tallies): (Vec<_>, Vec<_>) = vote_plan_status
+        .proposals
+        .iter()
+        .map(|proposal| {
+            let tally_state = proposal.tally.as_ref().unwrap();
+            let encrypted_tally = tally_state.private_encrypted().unwrap().0.clone();
             let decrypt_shares = members
                 .members()
                 .iter()
@@ -48,13 +34,21 @@ pub fn decrypt_tally(
             let validated_tally = encrypted_tally
                 .validate_partial_decryptions(&members_pks, &decrypt_shares)
                 .expect("Invalid shares");
-            let tally = validated_tally.decrypt_tally(max_votes, &table).unwrap();
-            DecryptedPrivateTallyProposal {
-                decrypt_shares: decrypt_shares.into_boxed_slice(),
-                tally_result: tally.votes.into_boxed_slice(),
-            }
+
+            (decrypt_shares, validated_tally)
         })
-        .collect::<Vec<_>>();
+        .unzip();
+
+    let tallies = batch_decrypt(&tallies).unwrap();
+
+    let proposals = shares
+        .into_iter()
+        .zip(tallies.into_iter())
+        .map(|(shares, tally)| DecryptedPrivateTallyProposal {
+            decrypt_shares: shares.into_boxed_slice(),
+            tally_result: tally.votes.into_boxed_slice(),
+        })
+        .collect();
 
     DecryptedPrivateTally::new(proposals)
 }

chain-impl-mockchain/src/testing/e2e/vote_private.rs

@@ -112,6 +112,73 @@ pub fn private_vote_cast_action_transfer_to_rewards_all_shares() {
         .has_remaining_rewards_equals_to(&Value(1100));
 }
 
+#[test]
+pub fn shouldnt_panic_when_no_initial_tokens_and_no_votes() {
+    let mut rng = TestGen::rand();
+    let favorable = Choice::new(1);
+    let members = VoteTestGen::committee_members_manager(MEMBERS_NO, THRESHOLD);
+
+    let (mut ledger, controller) = prepare_scenario()
+        .with_config(
+            ConfigBuilder::new()
+                .with_fee(LinearFee::new(1, 1, 1))
+                .with_rewards(Value(1000)),
+        )
+        .with_initials(vec![wallet(ALICE)
+            .with(1_000)
+            .owns(STAKE_POOL)
+            .committee_member()])
+        .with_vote_plans(vec![vote_plan(VOTE_PLAN)
+            .owner(ALICE)
+            .consecutive_epoch_dates()
+            .payload_type(PayloadType::Private)
+            .committee_keys(members.members_keys())
+            .with_proposal(
+                proposal(VoteTestGen::external_proposal_id())
+                    .options(3)
+                    .action_transfer_to_rewards(100),
+            )])
+        .build()
+        .unwrap();
+
+    let mut alice = controller.wallet(ALICE).unwrap();
+    let vote_plan = controller.vote_plan(VOTE_PLAN).unwrap();
+    let proposal = vote_plan.proposal(0);
+
+    controller
+        .cast_vote_private(
+            &alice,
+            &vote_plan,
+            &proposal.id(),
+            favorable,
+            &mut ledger,
+            &mut rng,
+        )
+        .unwrap();
+    alice.confirm_transaction();
+
+    ledger.fast_forward_to(BlockDate {
+        epoch: 1,
+        slot_id: 1,
+    });
+
+    controller
+        .encrypted_tally(&alice, &vote_plan, &mut ledger)
+        .unwrap();
+    alice.confirm_transaction();
+
+    let vote_plans = ledger.ledger.active_vote_plans();
+    let vote_plan_status = vote_plans
+        .iter()
+        .find(|c_vote_plan| {
+            let vote_plan: VotePlan = vote_plan.clone().into();
+            c_vote_plan.id == vote_plan.to_id()
+        })
+        .unwrap();
+
+    decrypt_tally(vote_plan_status, &members).unwrap();
+}
+
 #[test]
 #[should_panic]
 pub fn private_vote_plan_without_keys() {

chain-vote/src/math/babystep.rs

@@ -4,7 +4,7 @@
 use crate::Coordinate;
 use crate::{GroupElement, Scalar};
 use rayon::prelude::*;
-use std::collections::HashMap;
+use std::{collections::HashMap, num::NonZeroU64};
 
 // make steps asymmetric, in order to better use caching of baby steps.
 // balance of 2 means that baby steps are 2 time more than sqrt(max_votes)
@@ -25,8 +25,8 @@ pub struct BabyStepsTable {
 impl BabyStepsTable {
     /// Generate the table with asymmetrical steps,
     /// optimized for multiple reuse of the same table.
-    pub fn generate(max_value: u64) -> Self {
-        Self::generate_with_balance(max_value, DEFAULT_BALANCE)
+    pub fn generate(max_value: NonZeroU64) -> Self {
+        Self::generate_with_balance(max_value, DEFAULT_BALANCE.try_into().unwrap())
     }
 
     /// Generate the table with the given balance. Balance is used to make
@@ -36,9 +36,9 @@ impl BabyStepsTable {
     ///
     /// For example, a balance of 2 means that the table will precompute 2 times more
     /// baby steps than the standard O(sqrt(n)), 1 means symmetrical steps.
-    pub fn generate_with_balance(max_value: u64, balance: u64) -> Self {
-        let sqrt_step_size = (max_value as f64).sqrt().ceil() as u64;
-        let baby_step_size = sqrt_step_size * balance;
+    pub fn generate_with_balance(max_value: NonZeroU64, balance: NonZeroU64) -> Self {
+        let sqrt_step_size = (u64::from(max_value) as f64).sqrt().ceil() as u64;
+        let baby_step_size = sqrt_step_size * u64::from(balance);
         let mut bs = HashMap::new();
         let gen = GroupElement::generator();
         let mut e = GroupElement::zero();
@@ -57,7 +57,6 @@ impl BabyStepsTable {
             e = e + &gen;
         }
         assert!(!bs.is_empty());
-        assert!(baby_step_size > 0);
         Self {
             table: bs,
             baby_step_size,
@@ -117,15 +116,14 @@ mod tests {
         Generator,
     };
 
-    #[test]
-    #[should_panic]
-    fn table_not_empty() {
-        let _ = BabyStepsTable::generate_with_balance(0, 1);
+    /// helper to convert a numeric type to a `NonZeroU64`
+    fn nz<N: Into<i32>>(n: N) -> NonZeroU64 {
+        (n.into() as u64).try_into().unwrap()
     }
 
     #[test]
     fn quick() {
-        let table = BabyStepsTable::generate_with_balance(25, 1);
+        let table = BabyStepsTable::generate_with_balance(nz(25), nz(1));
         let p = GroupElement::generator();
         let votes = (0..100).collect::<Vec<_>>();
         let points = votes
@@ -151,14 +149,14 @@ mod tests {
 
     fn table_generator_default() -> BoxGenerator<BabyStepsTable> {
         generator::range::<u16>(1..u16::MAX)
-            .map(|a| BabyStepsTable::generate(a as u64))
+            .map(|a| BabyStepsTable::generate(NonZeroU64::try_from(a as u64).unwrap()))
             .into_boxed()
     }
 
     fn table_generator_with_balance() -> BoxGenerator<BabyStepsTable> {
         generator::range::<u16>(1..u16::MAX)
             .and(generator::range::<u8>(1..u8::MAX))
-            .map(|(n, b)| BabyStepsTable::generate_with_balance(n as u64, b as u64))
+            .map(|(n, b)| BabyStepsTable::generate_with_balance(nz(n), nz(b)))
             .into_boxed()
     }
 
@@ -173,7 +171,7 @@ mod tests {
 
                     property::equal(
                         ks,
-                        baby_step_giant_step(points.to_vec(), u16::MAX as u64, table).unwrap(),
+                        baby_step_giant_step(points.to_vec(), u16::MAX.into(), table).unwrap(),
                     )
                 })
                 .test(ctx);
@@ -182,7 +180,7 @@ mod tests {
                     let (points, ks): (Vec<_>, Vec<_>) = points.to_vec().into_iter().unzip();
                     property::equal(
                         ks,
-                        baby_step_giant_step(points.to_vec(), u16::MAX as u64, table).unwrap(),
+                        baby_step_giant_step(points.to_vec(), u16::MAX.into(), table).unwrap(),
                     )
                 })
                 .test(ctx);