Fix some Clippy warnings and update tests slightly

stanislav-tkach · stanislav-tkach · commit 9cad94cef915 · 2025-12-04T17:32:34.000+01:00
diff --git a/rust/catalyst-contest/src/choices.rs b/rust/catalyst-contest/src/choices.rs
@@ -49,7 +49,7 @@ impl Decode<'_, ()> for Choices {
             0 => Ok(Self::Clear(<Vec<i64>>::decode(d, ctx)?)),
             1 => {
                 let len = decode_array_len(d, "elgamal-ristretto255-encrypted-choices")?;
-                if len < 1 || len > 2 {
+                if !(1..=2).contains(&len) {
                     return Err(minicbor::decode::Error::message(format!(
                         "Unexpected elgamal-ristretto255-encrypted-choices array length {len}, expected 1 or 2"
                     )));
@@ -87,7 +87,7 @@ impl Encode<()> for Choices {
             Choices::ElgamalRistretto255 { choices, row_proof } => {
                 e.array(2)?;
                 1.encode(e, ctx)?;
-                e.array(choices.len() as u64 + row_proof.is_some() as u64)?;
+                e.array(choices.len() as u64 + u64::from(row_proof.is_some()))?;
                 choices.encode(e, ctx)?;
                 if let Some(row_proof) = row_proof {
                     row_proof.encode(e, ctx)?;
@@ -101,6 +101,7 @@ impl Encode<()> for Choices {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::row_proof::{ProofAnnouncement, ProofResponse, ProofScalar, SingleSelectionProof};
 
     #[test]
     fn clear_roundtrip() {
@@ -115,9 +116,23 @@ mod tests {
 
     #[test]
     fn elgamal_ristretto255_roundtrip() {
+        let bytes = [
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+            25, 26, 27, 28, 29, 30, 31, 32,
+        ];
         let original = Choices::ElgamalRistretto255 {
             choices: vec![],
-            row_proof: Some(RowProof {}),
+            row_proof: Some(RowProof {
+                selections: vec![SingleSelectionProof {
+                    announcement: ProofAnnouncement {},
+                    choice: ElgamalRistretto255Choice {
+                        c1: bytes,
+                        c2: bytes,
+                    },
+                    response: ProofResponse {},
+                }],
+                scalar: ProofScalar(bytes),
+            }),
         };
         let mut buffer = Vec::new();
         original
diff --git a/rust/catalyst-contest/src/contest_ballot.rs b/rust/catalyst-contest/src/contest_ballot.rs
@@ -35,12 +35,47 @@ impl Decode<'_, ()> for ContentBallot {
         d: &mut Decoder<'_>,
         ctx: &mut (),
     ) -> Result<Self, minicbor::decode::Error> {
+        use minicbor::data::Type;
+
         let len = decode_map_len(d, "content ballot")?;
-        // TODO: FIXME:
+
+        let mut choices = BTreeMap::new();
+        let mut column_proof = None;
+        let mut matrix_proof = None;
+        let mut voter_choices = None;
         for _ in 0..len {
-            // TODO: FIXME:
+            match d.datatype()? {
+                Type::U64 => {
+                    let key = d.u64()?;
+                    let val = Choices::decode(d, ctx)?;
+                    choices.insert(key, val);
+                },
+                Type::String => {
+                    match d.str()? {
+                        "column-proof" => column_proof = Some(ColumnProof::decode(d, ctx)?),
+                        "matrix-proof" => matrix_proof = Some(MatrixProof::decode(d, ctx)?),
+                        "voter-choices" => voter_choices = Some(EncryptedChoices::decode(d, ctx)?),
+                        key => {
+                            return Err(minicbor::decode::Error::message(format!(
+                                "Unexpected content ballot key value: {key:?}"
+                            )));
+                        },
+                    }
+                },
+                t => {
+                    return Err(minicbor::decode::Error::message(format!(
+                        "Unexpected content ballot key type: {t:?}"
+                    )));
+                },
+            }
         }
-        todo!()
+
+        Ok(Self {
+            choices,
+            column_proof,
+            matrix_proof,
+            voter_choices,
+        })
     }
 }
 
@@ -51,12 +86,12 @@ impl Encode<()> for ContentBallot {
         _ctx: &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         let len = self.choices.len() as u64
-            + self.column_proof.is_some() as u64
-            + self.matrix_proof.is_some() as u64
-            + self.voter_choices.is_some() as u64;
+            + u64::from(self.column_proof.is_some())
+            + u64::from(self.matrix_proof.is_some())
+            + u64::from(self.voter_choices.is_some());
         e.map(len)?;
 
-        for (&key, val) in self.choices.iter() {
+        for (&key, val) in &self.choices {
             e.u64(key)?.encode(val)?;
         }
         if let Some(column_proof) = self.column_proof.as_ref() {
@@ -76,7 +111,11 @@ impl Encode<()> for ContentBallot {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{EncryptedBlock, RowProof, elgamal_ristretto255_choice::ElgamalRistretto255Choice};
+    use crate::{
+        EncryptedBlock, RowProof,
+        elgamal_ristretto255_choice::ElgamalRistretto255Choice,
+        row_proof::{ProofAnnouncement, ProofResponse, ProofScalar, SingleSelectionProof},
+    };
 
     #[test]
     fn roundtrip() {
@@ -86,7 +125,7 @@ mod tests {
         ];
         let original = ContentBallot {
             choices: [
-                (1, Choices::Clear(vec![1, 2, 3, -4, -5].into())),
+                (1, Choices::Clear(vec![1, 2, 3, -4, -5])),
                 (2, Choices::ElgamalRistretto255 {
                     choices: vec![ElgamalRistretto255Choice {
                         c1: bytes,
@@ -99,7 +138,17 @@ mod tests {
                         c1: bytes,
                         c2: bytes,
                     }],
-                    row_proof: Some(RowProof {}),
+                    row_proof: Some(RowProof {
+                        selections: vec![SingleSelectionProof {
+                            announcement: ProofAnnouncement {},
+                            choice: ElgamalRistretto255Choice {
+                                c1: bytes,
+                                c2: bytes,
+                            },
+                            response: ProofResponse {},
+                        }],
+                        scalar: ProofScalar(bytes),
+                    }),
                 }),
             ]
             .into(),
diff --git a/rust/catalyst-contest/src/row_proof.rs b/rust/catalyst-contest/src/row_proof.rs
@@ -124,25 +124,9 @@ impl Encode<()> for RowProof {
 
 impl Decode<'_, ()> for SingleSelectionProof {
     fn decode(
-        d: &mut Decoder<'_>,
-        ctx: &mut (),
+        _d: &mut Decoder<'_>,
+        _ctx: &mut (),
     ) -> Result<Self, minicbor::decode::Error> {
-        let len = decode_array_len(d, "row proof")?;
-        if len != 3 {
-            return Err(minicbor::decode::Error::message(format!(
-                "Unexpected row proof array length {len}, expected 3"
-            )));
-        }
-
-        let announcement
-
-        /*
-        pub announcement: ProofAnnouncement,
-    /// An elgamal encrypted ciphertext.
-    pub choice: ElgamalRistretto255Choice,
-    /// A ZK proof response values for Ed25519.
-    pub response: ProofResponse,
-         */
         // TODO: FIXME:
         todo!()
     }
@@ -151,8 +135,8 @@ impl Decode<'_, ()> for SingleSelectionProof {
 impl Encode<()> for SingleSelectionProof {
     fn encode<W: Write>(
         &self,
-        e: &mut Encoder<W>,
-        ctx: &mut (),
+        _e: &mut Encoder<W>,
+        _ctx: &mut (),
     ) -> Result<(), minicbor::encode::Error<W::Error>> {
         // TODO: FIXME:
         todo!()
@@ -184,7 +168,21 @@ mod tests {
 
     #[test]
     fn row_proof_roundtrip() {
-        let original = RowProof {};
+        let bytes = [
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+            25, 26, 27, 28, 29, 30, 31, 32,
+        ];
+        let original = RowProof {
+            selections: vec![SingleSelectionProof {
+                announcement: ProofAnnouncement {},
+                choice: ElgamalRistretto255Choice {
+                    c1: bytes,
+                    c2: bytes,
+                },
+                response: ProofResponse {},
+            }],
+            scalar: ProofScalar(bytes),
+        };
         let mut buffer = Vec::new();
         original
             .encode(&mut Encoder::new(&mut buffer), &mut ())
@@ -195,7 +193,18 @@ mod tests {
 
     #[test]
     fn single_selection_proof_roundtrip() {
-        let original = SingleSelectionProof {};
+        let bytes = [
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+            25, 26, 27, 28, 29, 30, 31, 32,
+        ];
+        let original = SingleSelectionProof {
+            announcement: ProofAnnouncement {},
+            choice: ElgamalRistretto255Choice {
+                c1: bytes,
+                c2: bytes,
+            },
+            response: ProofResponse {},
+        };
         let mut buffer = Vec::new();
         original
             .encode(&mut Encoder::new(&mut buffer), &mut ())
