wip

Author: Mr-Leshiy

rust/jormungandr-vote-tx/Cargo.toml

@@ -13,6 +13,7 @@ workspace = true
 [dependencies]
 catalyst-voting = { path = "../catalyst-voting" }
 anyhow = "1.0.89"
+proptest = { version = "1.5.0", optional = true }
 
 [dev-dependencies]
 catalyst-voting = { path = "../catalyst-voting", features = ["proptest-arbitrary"] }
@@ -25,4 +26,4 @@ test-strategy = "0.4.0"
 [features]
 # Feature which makes publicly available
 # `proptest::prelude::Arbitrary` trait implementation for some types
-proptest-arbitrary = ["catalyst-voting/proptest-arbitrary"]
+proptest-arbitrary = ["catalyst-voting/proptest-arbitrary", "dep:proptest"]

rust/jormungandr-vote-tx/src/decoding.rs

@@ -214,129 +214,78 @@ impl Tx {
     }
 }
 
-// #[cfg(test)]
-// mod tests {
-//     use proptest::prelude::{any, any_with, Arbitrary, BoxedStrategy, Strategy};
-//     use test_strategy::proptest;
-
-//     use super::*;
-//     use crate::crypto::ed25519::PrivateKey;
-
-//     impl Arbitrary for Tx {
-//         type Parameters = ();
-//         type Strategy = BoxedStrategy<Self>;
-
-//         fn arbitrary_with((): Self::Parameters) -> Self::Strategy {
-//             any::<(
-//                 [u8; 32],
-//                 u8,
-//                 VotePayload,
-//                 PrivateKey,
-//                 [u8; Signature::BYTES_SIZE],
-//             )>()
-//             .prop_map(
-//                 |(vote_plan_id, proposal_index, vote, sk, signature_bytes)| {
-//                     Tx {
-//                         vote_plan_id,
-//                         proposal_index,
-//                         vote,
-//                         public_key: sk.public_key(),
-//                         signature: Signature::from_bytes(&signature_bytes),
-//                     }
-//                 },
-//             )
-//             .boxed()
-//         }
-//     }
-
-//     impl Arbitrary for VotePayload {
-//         type Parameters = ();
-//         type Strategy = BoxedStrategy<Self>;
-
-//         fn arbitrary_with((): Self::Parameters) -> Self::Strategy {
-//             any::<bool>()
-//                 .prop_flat_map(|b| {
-//                     if b {
-//                         any::<u8>().prop_map(VotePayload::Public).boxed()
-//                     } else {
-//                         any::<(u8, u8)>()
-//                             .prop_flat_map(|(s1, s2)| {
-//                                 any_with::<(EncryptedVote, VoterProof)>((s1.into(),
-// s2.into()))                                     .prop_map(|(v, p)|
-// VotePayload::Private(v, p))                             })
-//                             .boxed()
-//                     }
-//                 })
-//                 .boxed()
-//         }
-//     }
-
-//     #[proptest]
-//     fn tx_to_bytes_from_bytes_test(t1: Tx) {
-//         let bytes = t1.to_bytes();
-
-//         let mut reader = bytes.as_slice();
-
-//         let size = read_be_u32(&mut reader).unwrap();
-//         assert_eq!(size as usize, bytes.len() - 4);
-
-//         let padding_tag = read_be_u8(&mut reader).unwrap();
-//         assert_eq!(padding_tag, PADDING_TAG);
-
-//         let fragment_tag = read_be_u8(&mut reader).unwrap();
-//         assert_eq!(fragment_tag, FRAGMENT_TAG);
-
-//         let vote_plan_id = read_array(&mut reader).unwrap();
-//         assert_eq!(vote_plan_id, t1.vote_plan_id);
-
-//         let proposal_index = read_be_u8(&mut reader).unwrap();
-//         assert_eq!(proposal_index, t1.proposal_index);
-
-//         let vote_tag = read_be_u8(&mut reader).unwrap();
-//         assert!(vote_tag == PUBLIC_VOTE_TAG || vote_tag == PRIVATE_VOTE_TAG);
-//         match vote_tag {
-//             PUBLIC_VOTE_TAG => {
-//                 let vote = read_be_u8(&mut reader).unwrap();
-//                 assert_eq!(VotePayload::Public(vote), t1.vote);
-//             },
-//             PRIVATE_VOTE_TAG => {
-//                 let size = read_be_u8(&mut reader).unwrap();
-//                 let vote = EncryptedVote::from_bytes(&mut reader,
-// size.into()).unwrap();                 let size = read_be_u8(&mut reader).unwrap();
-//                 let proof = VoterProof::from_bytes(&mut reader, size.into()).unwrap();
-//                 assert_eq!(VotePayload::Private(vote, proof), t1.vote);
-//             },
-//             _ => {},
-//         }
-
-//         let block_date = read_be_u64(&mut reader).unwrap();
-//         assert_eq!(block_date, 0);
-
-//         let inputs_amount = read_be_u8(&mut reader).unwrap();
-//         assert_eq!(inputs_amount, NUMBER_OF_INPUTS);
-
-//         let outputs_amount = read_be_u8(&mut reader).unwrap();
-//         assert_eq!(outputs_amount, NUMBER_OF_OUTPUTS);
-
-//         let input_tag = read_be_u8(&mut reader).unwrap();
-//         assert_eq!(input_tag, INPUT_TAG);
-
-//         let value = read_be_u64(&mut reader).unwrap();
-//         assert_eq!(value, 0);
-
-//         let public_key = read_array(&mut reader).unwrap();
-//         assert_eq!(PublicKey::from_bytes(&public_key).unwrap(), t1.public_key);
-
-//         let witness_tag = read_be_u8(&mut reader).unwrap();
-//         assert_eq!(witness_tag, WITNESS_TAG);
-
-//         let nonce = read_be_u32(&mut reader).unwrap();
-//         assert_eq!(nonce, 0);
-
-//         let signature = read_array(&mut reader).unwrap();
-//         assert_eq!(Signature::from_bytes(&signature), t1.signature);
-
-//         let t2 = Tx::from_bytes(&mut bytes.as_slice()).unwrap();
-//         assert_eq!(t1, t2);
-//     }
-// }
+#[cfg(test)]
+mod tests {
+    use test_strategy::proptest;
+
+    use super::*;
+
+    #[proptest]
+    fn tx_to_bytes_from_bytes_test(t1: Tx) {
+        let bytes = t1.to_bytes();
+
+        let mut reader = bytes.as_slice();
+
+        let size = read_be_u32(&mut reader).unwrap();
+        assert_eq!(size as usize, bytes.len() - 4);
+
+        let padding_tag = read_be_u8(&mut reader).unwrap();
+        assert_eq!(padding_tag, PADDING_TAG);
+
+        let fragment_tag = read_be_u8(&mut reader).unwrap();
+        assert_eq!(fragment_tag, FRAGMENT_TAG);
+
+        let vote_plan_id = read_array(&mut reader).unwrap();
+        assert_eq!(vote_plan_id, t1.vote_plan_id);
+
+        let proposal_index = read_be_u8(&mut reader).unwrap();
+        assert_eq!(proposal_index, t1.proposal_index);
+
+        let vote_tag = read_be_u8(&mut reader).unwrap();
+        assert!(vote_tag == PUBLIC_VOTE_TAG || vote_tag == PRIVATE_VOTE_TAG);
+        match vote_tag {
+            PUBLIC_VOTE_TAG => {
+                let vote = read_be_u8(&mut reader).unwrap();
+                assert_eq!(VotePayload::Public(vote), t1.vote);
+            },
+            PRIVATE_VOTE_TAG => {
+                let size = read_be_u8(&mut reader).unwrap();
+                let vote = EncryptedVote::from_bytes(&mut reader, size.into()).unwrap();
+                let size = read_be_u8(&mut reader).unwrap();
+                let proof = VoterProof::from_bytes(&mut reader, size.into()).unwrap();
+                assert_eq!(VotePayload::Private(vote, proof), t1.vote);
+            },
+            _ => {},
+        }
+
+        let block_date = read_be_u64(&mut reader).unwrap();
+        assert_eq!(block_date, 0);
+
+        let inputs_amount = read_be_u8(&mut reader).unwrap();
+        assert_eq!(inputs_amount, NUMBER_OF_INPUTS);
+
+        let outputs_amount = read_be_u8(&mut reader).unwrap();
+        assert_eq!(outputs_amount, NUMBER_OF_OUTPUTS);
+
+        let input_tag = read_be_u8(&mut reader).unwrap();
+        assert_eq!(input_tag, INPUT_TAG);
+
+        let value = read_be_u64(&mut reader).unwrap();
+        assert_eq!(value, 0);
+
+        let public_key = read_array(&mut reader).unwrap();
+        assert_eq!(PublicKey::from_bytes(&public_key).unwrap(), t1.public_key);
+
+        let witness_tag = read_be_u8(&mut reader).unwrap();
+        assert_eq!(witness_tag, WITNESS_TAG);
+
+        let nonce = read_be_u32(&mut reader).unwrap();
+        assert_eq!(nonce, 0);
+
+        let signature = read_array(&mut reader).unwrap();
+        assert_eq!(Signature::from_bytes(&signature), t1.signature);
+
+        let t2 = Tx::from_bytes(&mut bytes.as_slice()).unwrap();
+        assert_eq!(t1, t2);
+    }
+}

rust/jormungandr-vote-tx/src/lib.rs

@@ -1,4 +1,5 @@
-//! A Jörmungandr transaction object structured following this [spec](https://input-output-hk.github.io/catalyst-libs/architecture/08_concepts/catalyst_voting/jorm/)
+//! A Jörmungandr transaction object structured following this
+//! [spec](https://input-output-hk.github.io/catalyst-libs/architecture/08_concepts/catalyst_voting/jorm/)
 //!
 //! ```rust
 //! use catalyst_voting::{
@@ -294,51 +295,110 @@ impl VotePayload {
     }
 }
 
-// #[cfg(test)]
-// mod tests {
-//     use test_strategy::proptest;
-
-//     use super::*;
-//     use crate::{crypto::ed25519::PrivateKey,
-// vote_protocol::committee::ElectionSecretKey};
-
-//     #[proptest]
-//     fn tx_test(
-//         vote_plan_id: [u8; 32], proposal_index: u8, #[strategy(1u8..5)] voting_options:
-// u8,         #[strategy(0..#voting_options)] choice: u8, users_private_key: PrivateKey,
-//         election_secret_key: ElectionSecretKey,
-//     ) {
-//         let election_public_key = election_secret_key.public_key();
-
-//         let tx = Tx::new_public(
-//             vote_plan_id,
-//             proposal_index,
-//             voting_options,
-//             choice,
-//             &users_private_key,
-//         )
-//         .unwrap();
-//         assert!(tx.is_public());
-//         assert!(!tx.is_private());
-//         tx.verify_signature().unwrap();
-//         tx.verify_proof(&election_public_key).unwrap();
-//         assert_eq!(tx.public_choice().unwrap(), choice);
-//         assert!(tx.private_choice(&election_secret_key).is_err());
-
-//         let tx = Tx::new_private_with_default_rng(
-//             vote_plan_id,
-//             proposal_index,
-//             voting_options,
-//             choice,
-//             &election_public_key,
-//             &users_private_key,
-//         )
-//         .unwrap();
-//         assert!(!tx.is_public());
-//         assert!(tx.is_private());
-//         tx.verify_signature().unwrap();
-//         tx.verify_proof(&election_public_key).unwrap();
-//         assert_eq!(tx.private_choice(&election_secret_key).unwrap(), choice);
-//         assert!(tx.public_choice().is_err());
-//     }
-// }
+#[cfg(any(test, feature = "proptest-arbitrary"))]
+#[allow(missing_docs, clippy::missing_docs_in_private_items)]
+mod arbitrary_impl {
+    use catalyst_voting::crypto::ed25519::PrivateKey;
+    use proptest::prelude::{any, any_with, Arbitrary, BoxedStrategy, Strategy};
+
+    use super::{EncryptedVote, Signature, Tx, VotePayload, VoterProof};
+
+    impl Arbitrary for Tx {
+        type Parameters = ();
+        type Strategy = BoxedStrategy<Self>;
+
+        fn arbitrary_with((): Self::Parameters) -> Self::Strategy {
+            any::<(
+                [u8; 32],
+                u8,
+                VotePayload,
+                PrivateKey,
+                [u8; Signature::BYTES_SIZE],
+            )>()
+            .prop_map(
+                |(vote_plan_id, proposal_index, vote, sk, signature_bytes)| {
+                    Tx {
+                        vote_plan_id,
+                        proposal_index,
+                        vote,
+                        public_key: sk.public_key(),
+                        signature: Signature::from_bytes(&signature_bytes),
+                    }
+                },
+            )
+            .boxed()
+        }
+    }
+
+    impl Arbitrary for VotePayload {
+        type Parameters = ();
+        type Strategy = BoxedStrategy<Self>;
+
+        fn arbitrary_with((): Self::Parameters) -> Self::Strategy {
+            any::<bool>()
+                .prop_flat_map(|b| {
+                    if b {
+                        any::<u8>().prop_map(VotePayload::Public).boxed()
+                    } else {
+                        any::<(u8, u8)>()
+                            .prop_flat_map(|(s1, s2)| {
+                                any_with::<(EncryptedVote, VoterProof)>((s1.into(), s2.into()))
+                                    .prop_map(|(v, p)| VotePayload::Private(v, p))
+                            })
+                            .boxed()
+                    }
+                })
+                .boxed()
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use catalyst_voting::{
+        crypto::ed25519::PrivateKey, vote_protocol::committee::ElectionSecretKey,
+    };
+    use test_strategy::proptest;
+
+    use super::*;
+
+    #[proptest]
+    fn tx_test(
+        vote_plan_id: [u8; 32], proposal_index: u8, #[strategy(1u8..5)] voting_options: u8,
+        #[strategy(0..#voting_options)] choice: u8, users_private_key: PrivateKey,
+        election_secret_key: ElectionSecretKey,
+    ) {
+        let election_public_key = election_secret_key.public_key();
+
+        let tx = Tx::new_public(
+            vote_plan_id,
+            proposal_index,
+            voting_options,
+            choice,
+            &users_private_key,
+        )
+        .unwrap();
+        assert!(tx.is_public());
+        assert!(!tx.is_private());
+        tx.verify_signature().unwrap();
+        tx.verify_proof(&election_public_key).unwrap();
+        assert_eq!(tx.public_choice().unwrap(), choice);
+        assert!(tx.private_choice(&election_secret_key).is_err());
+
+        let tx = Tx::new_private_with_default_rng(
+            vote_plan_id,
+            proposal_index,
+            voting_options,
+            choice,
+            &election_public_key,
+            &users_private_key,
+        )
+        .unwrap();
+        assert!(!tx.is_public());
+        assert!(tx.is_private());
+        tx.verify_signature().unwrap();
+        tx.verify_proof(&election_public_key).unwrap();
+        assert_eq!(tx.private_choice(&election_secret_key).unwrap(), choice);
+        assert!(tx.public_choice().is_err());
+    }
+}