Create the catalyst-contest crate

Author: stanislav-tkach

rust/Cargo.toml

@@ -9,6 +9,7 @@ members = [
     "cbork-abnf-parser",
     "cbork-cddl-parser",
     "cbork-utils",
+    "catalyst-contest",
     "catalyst-voting",
     "catalyst-types",
     "immutable-ledger",

rust/catalyst-contest/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "catalyst-contest"
+description = "Catalyst voting (contest)"
+keywords = ["cardano", "catalyst", "voting", "contest"]
+version = "0.0.1"
+edition.workspace = true
+authors.workspace = true
+homepage.workspace = true
+repository.workspace = true
+license.workspace = true
+
+[lints]
+workspace = true
+
+[dependencies]
+minicbor = { version = "0.25.1", features = ["alloc", "derive", "half"] }
+
+cbork-utils = { version = "0.0.2", git = "https://github.com/input-output-hk/catalyst-libs.git", tag = "cbork-utils-v0.0.2" }

rust/catalyst-contest/src/choices.rs

@@ -0,0 +1,172 @@
+//! Voters Choices.
+
+use minicbor::{Decode, Decoder, Encode, Encoder, encode::Write};
+
+/// Voters Choices.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum Choices {
+    /// A universal unencrypted set of choices.
+    Clear(Vec<i64>),
+    /// ElGamal/Ristretto255 encrypted choices.
+    ElgamalRistretto255 {
+        /// ElGamal/Ristretto255 encrypted choices.
+        choices: Vec<ElgamalRistretto255Choice>,
+        /// A universal encrypted row proof.
+        row_proof: Option<RowProof>,
+    },
+}
+
+/// An elgamal encrypted ciphertext `(c1, c2)`.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct ElgamalRistretto255Choice {
+    /// An individual Elgamal group element that composes the elgamal cipher text.
+    pub c1: [u8; 32],
+    /// An individual Elgamal group element that composes the elgamal cipher text.
+    pub c2: [u8; 32],
+}
+
+/// A universal encrypted row proof.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct RowProof {
+    // TODO: FIXME:
+}
+
+impl Decode<'_, ()> for Choices {
+    fn decode(
+        d: &mut Decoder<'_>,
+        ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
+        // TODO: FIXME:
+        todo!()
+    }
+}
+
+impl Encode<()> for Choices {
+    fn encode<W: Write>(
+        &self,
+        e: &mut Encoder<W>,
+        ctx: &mut (),
+    ) -> Result<(), minicbor::encode::Error<W::Error>> {
+        match self {
+            Choices::Clear(choices) => {
+                e.array(choices.len() as u64 + 1)?;
+                0.encode(e, ctx)?;
+                for choice in choices {
+                    choice.encode(e, ctx)?;
+                }
+            },
+            Choices::ElgamalRistretto255 { choices, row_proof } => {
+                e.array(2)?;
+                1.encode(e, ctx)?;
+                e.array(choices.len() as u64 + row_proof.is_some() as u64)?;
+                choices.encode(e, ctx)?;
+                if let Some(row_proof) = row_proof {
+                    row_proof.encode(e, ctx)?;
+                }
+            },
+        }
+        Ok(())
+    }
+}
+
+impl Decode<'_, ()> for ElgamalRistretto255Choice {
+    fn decode(
+        d: &mut Decoder<'_>,
+        ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
+        // TODO: FIXME:
+        todo!()
+    }
+}
+
+impl Encode<()> for ElgamalRistretto255Choice {
+    fn encode<W: Write>(
+        &self,
+        e: &mut Encoder<W>,
+        ctx: &mut (),
+    ) -> Result<(), minicbor::encode::Error<W::Error>> {
+        // TODO: FIXME:
+        todo!()
+    }
+}
+
+impl Decode<'_, ()> for RowProof {
+    fn decode(
+        d: &mut Decoder<'_>,
+        ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
+        // TODO: FIXME:
+        todo!()
+    }
+}
+
+impl Encode<()> for RowProof {
+    fn encode<W: Write>(
+        &self,
+        e: &mut Encoder<W>,
+        ctx: &mut (),
+    ) -> Result<(), minicbor::encode::Error<W::Error>> {
+        // TODO: FIXME:
+        todo!()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn clear_choices_roundtrip() {
+        let original = Choices::Clear(vec![1, 2, 3]);
+        let mut buffer = Vec::new();
+        original
+            .encode(&mut Encoder::new(&mut buffer), &mut ())
+            .unwrap();
+        let decoded = Choices::decode(&mut Decoder::new(&buffer), &mut ()).unwrap();
+        assert_eq!(original, decoded);
+    }
+
+    #[test]
+    fn elgamal_ristretto255_choices_roundtrip() {
+        let original = Choices::ElgamalRistretto255 {
+            choices: vec![],
+            row_proof: Some(RowProof {}),
+        };
+        let mut buffer = Vec::new();
+        original
+            .encode(&mut Encoder::new(&mut buffer), &mut ())
+            .unwrap();
+        let decoded = Choices::decode(&mut Decoder::new(&buffer), &mut ()).unwrap();
+        assert_eq!(original, decoded);
+    }
+
+    #[test]
+    fn elgamal_ristretto255_choice_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 = ElgamalRistretto255Choice {
+            c1: bytes,
+            c2: bytes,
+        };
+        let mut buffer = Vec::new();
+        original
+            .encode(&mut Encoder::new(&mut buffer), &mut ())
+            .unwrap();
+        let decoded =
+            ElgamalRistretto255Choice::decode(&mut Decoder::new(&buffer), &mut ()).unwrap();
+        assert_eq!(original, decoded);
+    }
+
+    #[test]
+    fn row_proof_roundtrip() {
+        let original = RowProof {};
+        let mut buffer = Vec::new();
+        original
+            .encode(&mut Encoder::new(&mut buffer), &mut ())
+            .unwrap();
+        let decoded = RowProof::decode(&mut Decoder::new(&buffer), &mut ()).unwrap();
+        assert_eq!(original, decoded);
+    }
+}

rust/catalyst-contest/src/column_proof.rs

@@ -0,0 +1,63 @@
+//! A universal encrypted column proof.
+
+use cbork_utils::decode_helper::decode_array_len;
+use minicbor::{Decode, Decoder, Encode, Encoder, encode::Write};
+
+/// A length of the underlying CBOR array.
+const ARRAY_LEN: u64 = 2;
+
+/// A universal encrypted column proof.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct ColumnProof(pub u64);
+
+impl Decode<'_, ()> for ColumnProof {
+    fn decode(
+        d: &mut Decoder<'_>,
+        ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
+        let len = decode_array_len(d, "column proof")?;
+        if len != ARRAY_LEN {
+            return Err(minicbor::decode::Error::message(format!(
+                "Unexpected column proof array length {len}, expected {ARRAY_LEN}"
+            )));
+        }
+        let val = u64::decode(d, ctx)?;
+
+        let len = decode_array_len(d, "column proof undefined part")?;
+        for _ in 0..len {
+            d.undefined()?;
+        }
+
+        Ok(ColumnProof(val))
+    }
+}
+
+impl Encode<()> for ColumnProof {
+    fn encode<W: Write>(
+        &self,
+        e: &mut Encoder<W>,
+        ctx: &mut (),
+    ) -> Result<(), minicbor::encode::Error<W::Error>> {
+        e.array(ARRAY_LEN)?;
+        self.0.encode(e, ctx)?;
+        e.array(1)?;
+        e.undefined()?;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn roundtrip() {
+        let original = ColumnProof(1);
+        let mut buffer = Vec::new();
+        original
+            .encode(&mut Encoder::new(&mut buffer), &mut ())
+            .unwrap();
+        let decoded = ColumnProof::decode(&mut Decoder::new(&buffer), &mut ()).unwrap();
+        assert_eq!(original, decoded);
+    }
+}

rust/catalyst-contest/src/contest_ballot.rs

@@ -0,0 +1,103 @@
+//! An individual Ballot cast in a Contest by a registered user.
+
+use std::collections::BTreeMap;
+
+use minicbor::{Decode, Decoder, Encode, Encoder, encode::Write};
+
+use crate::{Choices, ColumnProof, EncryptedChoices, MatrixProof};
+
+/// An individual Ballot cast in a Contest by a registered user.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct ContentBallot {
+    /// A map of voters choices.
+    pub choices: BTreeMap<u64, Choices>,
+    /// A universal encrypted column proof.
+    pub column_proof: Option<ColumnProof>,
+    /// A universal encrypted matrix proof.
+    pub matrix_proof: Option<MatrixProof>,
+    /// An encrypted voter choice payload.
+    pub voter_choices: Option<EncryptedChoices>,
+}
+
+impl Decode<'_, ()> for ContentBallot {
+    fn decode(
+        d: &mut Decoder<'_>,
+        ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
+        d.map()?;
+        // TODO: FIXME:
+        todo!()
+    }
+}
+
+impl Encode<()> for ContentBallot {
+    fn encode<W: Write>(
+        &self,
+        e: &mut Encoder<W>,
+        ctx: &mut (),
+    ) -> Result<(), minicbor::encode::Error<W::Error>> {
+        e.begin_map()?;
+
+        for (&key, val) in self.choices.iter() {
+            e.u64(key)?.encode(val)?;
+        }
+        if let Some(column_proof) = self.column_proof.as_ref() {
+            e.str("column-proof")?.encode(column_proof)?;
+        }
+        if let Some(matrix_proof) = self.matrix_proof.as_ref() {
+            e.str("matrix-proof")?.encode(matrix_proof)?;
+        }
+        if let Some(voter_choices) = self.voter_choices.as_ref() {
+            e.str("voter-choices")?.encode(voter_choices)?;
+        }
+
+        e.end()?;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{ElgamalRistretto255Choice, EncryptedBlock, RowProof};
+
+    #[test]
+    fn 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 = ContentBallot {
+            choices: [
+                (1, Choices::Clear(vec![1, 2, 3, -4, -5].into())),
+                (2, Choices::ElgamalRistretto255 {
+                    choices: vec![ElgamalRistretto255Choice {
+                        c1: bytes,
+                        c2: bytes,
+                    }],
+                    row_proof: None,
+                }),
+                (3, Choices::ElgamalRistretto255 {
+                    choices: vec![ElgamalRistretto255Choice {
+                        c1: bytes,
+                        c2: bytes,
+                    }],
+                    row_proof: Some(RowProof {}),
+                }),
+            ]
+            .into(),
+            column_proof: Some(ColumnProof(1)),
+            matrix_proof: Some(MatrixProof(2)),
+            voter_choices: Some(EncryptedChoices(vec![
+                EncryptedBlock([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]),
+                EncryptedBlock([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]),
+            ])),
+        };
+        let mut buffer = Vec::new();
+        original
+            .encode(&mut Encoder::new(&mut buffer), &mut ())
+            .unwrap();
+        let decoded = ContentBallot::decode(&mut Decoder::new(&buffer), &mut ()).unwrap();
+        assert_eq!(original, decoded);
+    }
+}