ProofResponse, ProofAnnouncementElement, etc.

stanislav-tkach · stanislav-tkach · commit 7de11cc96c8d · 2025-12-04T19:24:31.000+01:00
diff --git a/rust/catalyst-contest/src/choices.rs b/rust/catalyst-contest/src/choices.rs
@@ -101,7 +101,10 @@ impl Encode<()> for Choices {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::row_proof::{ProofAnnouncement, ProofResponse, ProofScalar, SingleSelectionProof};
+    use crate::row_proof::{
+        ProofAnnouncement, ProofAnnouncementElement, ProofResponse, ProofScalar,
+        SingleSelectionProof,
+    };
 
     #[test]
     fn clear_roundtrip() {
@@ -124,12 +127,20 @@ mod tests {
             choices: vec![],
             row_proof: Some(RowProof {
                 selections: vec![SingleSelectionProof {
-                    announcement: ProofAnnouncement {},
+                    announcement: ProofAnnouncement(
+                        ProofAnnouncementElement(bytes),
+                        ProofAnnouncementElement(bytes),
+                        ProofAnnouncementElement(bytes),
+                    ),
                     choice: ElgamalRistretto255Choice {
                         c1: bytes,
                         c2: bytes,
                     },
-                    response: ProofResponse {},
+                    response: ProofResponse(
+                        ProofScalar(bytes),
+                        ProofScalar(bytes),
+                        ProofScalar(bytes),
+                    ),
                 }],
                 scalar: ProofScalar(bytes),
             }),
diff --git a/rust/catalyst-contest/src/contest_ballot.rs b/rust/catalyst-contest/src/contest_ballot.rs
@@ -114,7 +114,10 @@ mod tests {
     use crate::{
         EncryptedBlock, RowProof,
         elgamal_ristretto255_choice::ElgamalRistretto255Choice,
-        row_proof::{ProofAnnouncement, ProofResponse, ProofScalar, SingleSelectionProof},
+        row_proof::{
+            ProofAnnouncement, ProofAnnouncementElement, ProofResponse, ProofScalar,
+            SingleSelectionProof,
+        },
     };
 
     #[test]
@@ -140,12 +143,20 @@ mod tests {
                     }],
                     row_proof: Some(RowProof {
                         selections: vec![SingleSelectionProof {
-                            announcement: ProofAnnouncement {},
+                            announcement: ProofAnnouncement(
+                                ProofAnnouncementElement(bytes),
+                                ProofAnnouncementElement(bytes),
+                                ProofAnnouncementElement(bytes),
+                            ),
                             choice: ElgamalRistretto255Choice {
                                 c1: bytes,
                                 c2: bytes,
                             },
-                            response: ProofResponse {},
+                            response: ProofResponse(
+                                ProofScalar(bytes),
+                                ProofScalar(bytes),
+                                ProofScalar(bytes),
+                            ),
                         }],
                         scalar: ProofScalar(bytes),
                     }),
diff --git a/rust/catalyst-contest/src/row_proof.rs b/rust/catalyst-contest/src/row_proof.rs
@@ -5,8 +5,24 @@ use minicbor::{Decode, Decoder, Encode, Encoder, encode::Write};
 
 use crate::ElgamalRistretto255Choice;
 
+/// A length of the underlying CBOR array of the `ProofScalar` type.
 const SCALAR_PROOF_LEN: u64 = 32;
 
+/// A length of the underlying CBOR array of the `ProofAnnouncementElement` type.
+const PROOF_ANNOUNCEMENT_ELEMENT_LEN: u64 = 32;
+
+/// A minimal length (number of elements) of the
+/// `zkproof-elgamal-ristretto255-unit-vector-with-single-selection` array.
+///
+///
+/// The number of elements consists of the following:
+/// - 7 (zkproof-elgamal-ristretto255-unit-vector-with-single-selection-item)
+///      - 3 (zkproof-elgamal-announcement = x3 zkproof-elgamal-group-element)
+///      - 1 (elgamal-ristretto255-encrypted-choice)
+///      - 3 (zkproof-ed25519-r-response = x3 zkproof-ed25519-scalar)
+/// - 1 (zkproof-ed25519-scalar)
+const MIN_SELECTION_LEN: u64 = 8;
+
 /// A universal encrypted row proof.
 ///
 /// The CDDL schema:
@@ -57,7 +73,20 @@ pub struct ProofScalar(pub [u8; SCALAR_PROOF_LEN as usize]);
 /// zkproof-elgamal-group-element = bytes .size 32
 /// ```
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct ProofAnnouncement {}
+pub struct ProofAnnouncement(
+    pub ProofAnnouncementElement,
+    pub ProofAnnouncementElement,
+    pub ProofAnnouncementElement,
+);
+
+/// An individual Elgamal group element used in ZK proofs.
+///
+/// The CDDL schema:
+/// ```cddl
+/// zkproof-elgamal-group-element = bytes .size 32
+/// ```
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct ProofAnnouncementElement(pub [u8; PROOF_ANNOUNCEMENT_ELEMENT_LEN as usize]);
 
 /// A ZK proof response values for Ed25519.
 ///
@@ -67,7 +96,7 @@ pub struct ProofAnnouncement {}
 /// zkproof-ed25519-r-response = ( zkproof-ed25519-scalar, zkproof-ed25519-scalar, zkproof-ed25519-scalar )
 /// ```
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct ProofResponse {}
+pub struct ProofResponse(pub ProofScalar, pub ProofScalar, pub ProofScalar);
 
 impl Decode<'_, ()> for RowProof {
     fn decode(
@@ -88,17 +117,16 @@ impl Decode<'_, ()> for RowProof {
         }
 
         let len = decode_array_len(d, "row proof single selection")?;
-        if len < 2 {
+        if len < MIN_SELECTION_LEN || !len.is_multiple_of(MIN_SELECTION_LEN) {
             return Err(minicbor::decode::Error::message(format!(
-                "Unexpected row proof single selection array length {len}, expected ata least 2"
+                "Unexpected row proof single selection array length {len}, expected multiplier of {MIN_SELECTION_LEN}"
             )));
         }
 
         let mut selections = Vec::with_capacity(len as usize - 1);
-        for _ in 0..len - 1 {
+        for _ in 0..len / MIN_SELECTION_LEN {
             selections.push(SingleSelectionProof::decode(d, ctx)?);
         }
-
         let scalar = ProofScalar::decode(d, ctx)?;
 
         Ok(Self { selections, scalar })
@@ -114,7 +142,7 @@ impl Encode<()> for RowProof {
         e.array(2)?;
         0.encode(e, ctx)?;
 
-        e.array(self.selections.len() as u64 + 1)?;
+        e.array(MIN_SELECTION_LEN * self.selections.len() as u64 + 1)?;
         for selection in &self.selections {
             selection.encode(e, ctx)?;
         }
@@ -124,22 +152,30 @@ 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> {
-        // TODO: FIXME:
-        todo!()
+        let announcement = ProofAnnouncement::decode(d, ctx)?;
+        let choice = ElgamalRistretto255Choice::decode(d, ctx)?;
+        let response = ProofResponse::decode(d, ctx)?;
+
+        Ok(Self {
+            announcement,
+            choice,
+            response,
+        })
     }
 }
 
 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!()
+        self.announcement.encode(e, ctx)?;
+        self.choice.encode(e, ctx)?;
+        self.response.encode(e, ctx)
     }
 }
 
@@ -162,6 +198,75 @@ impl Encode<()> for ProofScalar {
     }
 }
 
+impl Decode<'_, ()> for ProofAnnouncement {
+    fn decode(
+        d: &mut Decoder<'_>,
+        ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
+        Ok(Self(
+            ProofAnnouncementElement::decode(d, ctx)?,
+            ProofAnnouncementElement::decode(d, ctx)?,
+            ProofAnnouncementElement::decode(d, ctx)?,
+        ))
+    }
+}
+
+impl Encode<()> for ProofAnnouncement {
+    fn encode<W: Write>(
+        &self,
+        e: &mut Encoder<W>,
+        ctx: &mut (),
+    ) -> Result<(), minicbor::encode::Error<W::Error>> {
+        self.0.encode(e, ctx)?;
+        self.1.encode(e, ctx)?;
+        self.2.encode(e, ctx)
+    }
+}
+
+impl Decode<'_, ()> for ProofResponse {
+    fn decode(
+        d: &mut Decoder<'_>,
+        ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
+        Ok(Self(
+            ProofScalar::decode(d, ctx)?,
+            ProofScalar::decode(d, ctx)?,
+            ProofScalar::decode(d, ctx)?,
+        ))
+    }
+}
+
+impl Encode<()> for ProofResponse {
+    fn encode<W: Write>(
+        &self,
+        e: &mut Encoder<W>,
+        ctx: &mut (),
+    ) -> Result<(), minicbor::encode::Error<W::Error>> {
+        self.0.encode(e, ctx)?;
+        self.1.encode(e, ctx)?;
+        self.2.encode(e, ctx)
+    }
+}
+
+impl Decode<'_, ()> for ProofAnnouncementElement {
+    fn decode(
+        d: &mut Decoder<'_>,
+        ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
+        <[u8; PROOF_ANNOUNCEMENT_ELEMENT_LEN as usize]>::decode(d, ctx).map(Self)
+    }
+}
+
+impl Encode<()> for ProofAnnouncementElement {
+    fn encode<W: Write>(
+        &self,
+        e: &mut Encoder<W>,
+        ctx: &mut (),
+    ) -> Result<(), minicbor::encode::Error<W::Error>> {
+        self.0.encode(e, ctx)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -174,12 +279,16 @@ mod tests {
         ];
         let original = RowProof {
             selections: vec![SingleSelectionProof {
-                announcement: ProofAnnouncement {},
+                announcement: ProofAnnouncement(
+                    ProofAnnouncementElement(bytes),
+                    ProofAnnouncementElement(bytes),
+                    ProofAnnouncementElement(bytes),
+                ),
                 choice: ElgamalRistretto255Choice {
                     c1: bytes,
                     c2: bytes,
                 },
-                response: ProofResponse {},
+                response: ProofResponse(ProofScalar(bytes), ProofScalar(bytes), ProofScalar(bytes)),
             }],
             scalar: ProofScalar(bytes),
         };
@@ -198,12 +307,16 @@ mod tests {
             25, 26, 27, 28, 29, 30, 31, 32,
         ];
         let original = SingleSelectionProof {
-            announcement: ProofAnnouncement {},
+            announcement: ProofAnnouncement(
+                ProofAnnouncementElement(bytes),
+                ProofAnnouncementElement(bytes),
+                ProofAnnouncementElement(bytes),
+            ),
             choice: ElgamalRistretto255Choice {
                 c1: bytes,
                 c2: bytes,
             },
-            response: ProofResponse {},
+            response: ProofResponse(ProofScalar(bytes), ProofScalar(bytes), ProofScalar(bytes)),
         };
         let mut buffer = Vec::new();
         original
