update voting_test

Author: Mr-Leshiy

rust/catalyst-voting/src/crypto/elgamal.rs

@@ -12,7 +12,7 @@ use crate::crypto::group::{GroupElement, Scalar};
 pub struct SecretKey(Scalar);
 
 /// ``ElGamal`` public key.
-#[derive(Debug, Clone, Eq, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct PublicKey(GroupElement);
 
 /// ``ElGamal`` ciphertext, encrypted message with the public key.

rust/catalyst-voting/src/voter/mod.rs

@@ -13,6 +13,7 @@ use crate::crypto::{
 /// Represented as a Unit vector which size is `voting_options`
 /// and the `choice` value is the index of the unit vector component equals to `1`,
 /// and other components equal to `0`.
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Vote {
     /// Voter's voting choice.
     choice: usize,
@@ -21,9 +22,11 @@ pub struct Vote {
 }
 
 /// A representation of the encrypted vote.
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct EncryptedVote(Vec<Ciphertext>);
 
 /// A representation of the encryption randomness, used to encrypt the vote.
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct EncryptionRandomness(Vec<Scalar>);
 
 impl EncryptionRandomness {

rust/catalyst-voting/src/voter/proof.rs

@@ -70,8 +70,8 @@ pub fn generate_voter_proof<R: CryptoRngCore>(
 #[must_use]
 #[allow(clippy::module_name_repetitions)]
 pub fn verify_voter_proof(
-    encrypted_vote: EncryptedVote, public_key: &PublicKey, commitment_key: &PublicKey,
+    encrypted_vote: EncryptedVote, public_key: &PublicKey, commitment: &VoterProofCommitment,
     proof: &VoterProof,
 ) -> bool {
-    verify_unit_vector_proof(&proof.0, encrypted_vote.0, public_key, commitment_key)
+    verify_unit_vector_proof(&proof.0, encrypted_vote.0, public_key, &commitment.0)
 }

rust/catalyst-voting/tests/voting_test.rs

@@ -6,7 +6,11 @@ use catalyst_voting::{
         proof::{generate_tally_proof, verify_tally_proof},
         tally, DecryptionTallySetup,
     },
-    voter::{encrypt_vote, Vote},
+    voter::{
+        encrypt_vote,
+        proof::{generate_voter_proof, verify_voter_proof, VoterProofCommitment},
+        Vote,
+    },
     SecretKey,
 };
 use proptest::prelude::ProptestConfig;
@@ -28,17 +32,51 @@ fn voting_test(voters: [Voter; 100]) {
 
     let election_secret_key = SecretKey::random(&mut rng);
     let election_public_key = election_secret_key.public_key();
+    let voter_proof_commitment = VoterProofCommitment::random(&mut rng);
 
     let votes: Vec<_> = voters
         .iter()
         .map(|voter| Vote::new(voter.choice, VOTING_OPTIONS).unwrap())
         .collect();
 
-    let (encrypted_votes, _randomness): (Vec<_>, Vec<_>) = votes
+    let (encrypted_votes, randomness): (Vec<_>, Vec<_>) = votes
         .iter()
         .map(|vote| encrypt_vote(vote, &election_public_key, &mut rng))
         .unzip();
 
+    // Verify encrypted votes
+    {
+        let voter_proofs: Vec<_> = votes
+            .iter()
+            .zip(encrypted_votes.iter())
+            .zip(randomness.iter())
+            .map(|((v, enc_v), r)| {
+                generate_voter_proof(
+                    v,
+                    enc_v.clone(),
+                    r.clone(),
+                    &election_public_key,
+                    &voter_proof_commitment,
+                    &mut rng,
+                )
+                .unwrap()
+            })
+            .collect();
+
+        let is_ok = voter_proofs
+            .iter()
+            .zip(encrypted_votes.iter())
+            .all(|(p, enc_v)| {
+                verify_voter_proof(
+                    enc_v.clone(),
+                    &election_public_key,
+                    &voter_proof_commitment,
+                    p,
+                )
+            });
+        assert!(is_ok);
+    }
+
     let voting_powers: Vec<_> = voters
         .iter()
         .map(|voter| u64::from(voter.voting_power))
@@ -51,22 +89,25 @@ fn voting_test(voters: [Voter; 100]) {
     let total_voting_power = voting_powers.iter().sum();
     let decryption_tally_setup = DecryptionTallySetup::new(total_voting_power).unwrap();
 
-    let tally_proofs: Vec<_> = encrypted_tallies
-        .iter()
-        .map(|t| generate_tally_proof(t, &election_secret_key, &mut rng))
-        .collect();
-
     let decrypted_tallies: Vec<_> = encrypted_tallies
         .iter()
         .map(|t| decrypt_tally(t, &election_secret_key, &decryption_tally_setup).unwrap())
         .collect();
 
-    let is_ok = tally_proofs
-        .iter()
-        .zip(encrypted_tallies.iter())
-        .zip(decrypted_tallies.iter())
-        .all(|((p, enc_t), t)| verify_tally_proof(enc_t, *t, &election_public_key, p));
-    assert!(is_ok);
+    // Verify tallies
+    {
+        let tally_proofs: Vec<_> = encrypted_tallies
+            .iter()
+            .map(|t| generate_tally_proof(t, &election_secret_key, &mut rng))
+            .collect();
+
+        let is_ok = tally_proofs
+            .iter()
+            .zip(encrypted_tallies.iter())
+            .zip(decrypted_tallies.iter())
+            .all(|((p, enc_t), t)| verify_tally_proof(enc_t, *t, &election_public_key, p));
+        assert!(is_ok);
+    }
 
     let expected_tallies: Vec<_> = (0..VOTING_OPTIONS)
         .map(|i| {