refactor

Author: Mr-Leshiy

rust/catalyst-voting/src/crypto/zk_unit_vector/decoding.rs

@@ -21,43 +21,43 @@ impl UnitVectorProof {
     ///   - Cannot decode ciphertext value.
     ///   - Cannot decode response randomness value.
     ///   - Cannot decode scalar value.
-    pub fn from_bytes(mut bytes: &[u8], len: usize) -> anyhow::Result<Self> {
+    pub fn from_bytes<R: Read>(reader: &mut R, len: usize) -> anyhow::Result<Self> {
         let mut ann_buf = [0u8; Announcement::BYTES_SIZE];
         let mut dl_buf = [0u8; Ciphertext::BYTES_SIZE];
         let mut rr_buf = [0u8; ResponseRandomness::BYTES_SIZE];
 
         let ann = (0..len)
             .map(|i| {
-                bytes.read_exact(&mut ann_buf)?;
+                reader.read_exact(&mut ann_buf)?;
                 Announcement::from_bytes(&ann_buf)
                     .map_err(|e| anyhow!("Cannot decode announcement at {i}, error: {e}."))
             })
             .collect::<anyhow::Result<_>>()?;
         let dl = (0..len)
             .map(|i| {
-                bytes.read_exact(&mut dl_buf)?;
+                reader.read_exact(&mut dl_buf)?;
                 Ciphertext::from_bytes(&dl_buf)
                     .map_err(|e| anyhow!("Cannot decode ciphertext at {i}, error: {e}."))
             })
             .collect::<anyhow::Result<_>>()?;
         let rr = (0..len)
             .map(|i| {
-                bytes.read_exact(&mut rr_buf)?;
+                reader.read_exact(&mut rr_buf)?;
                 ResponseRandomness::from_bytes(&rr_buf)
                     .map_err(|e| anyhow!("Cannot decode response randomness at {i}, error: {e}."))
             })
             .collect::<anyhow::Result<_>>()?;
 
         let mut scalar_buf = [0u8; Scalar::BYTES_SIZE];
-        bytes.read_exact(&mut scalar_buf)?;
+        reader.read_exact(&mut scalar_buf)?;
         let scalar =
             Scalar::from_bytes(scalar_buf).map_err(|_| anyhow!("Cannot decode scalar field."))?;
         Ok(Self(ann, dl, rr, scalar))
     }
 
     /// Get a deserialized bytes size
     #[must_use]
-    pub fn bytes_size(&self) -> usize {
+    fn bytes_size(&self) -> usize {
         Scalar::BYTES_SIZE
             + self.0.len() * Announcement::BYTES_SIZE
             + self.0.len() * Ciphertext::BYTES_SIZE
@@ -144,6 +144,8 @@ impl ResponseRandomness {
 
 #[cfg(test)]
 mod tests {
+    use std::io::Cursor;
+
     use test_strategy::proptest;
 
     use super::*;
@@ -154,7 +156,7 @@ mod tests {
     ) {
         let bytes = p1.to_bytes();
         assert_eq!(bytes.len(), p1.bytes_size());
-        let p2 = UnitVectorProof::from_bytes(&bytes, p1.size()).unwrap();
+        let p2 = UnitVectorProof::from_bytes(&mut Cursor::new(bytes), p1.size()).unwrap();
         assert_eq!(p1, p2);
     }
 

rust/catalyst-voting/src/txs/v1/decoding.rs

@@ -44,6 +44,7 @@ impl Tx {
         tx_body.push(0xFF);
         // Zero value
         tx_body.extend_from_slice(&[0u8; 8]);
+
         tx_body.extend_from_slice(&self.public_key.to_bytes());
 
         // Add the size of decoded bytes to the beginning.
@@ -62,91 +63,83 @@ impl Tx {
     ///   - Invalid vote tag value.
     ///   - Invalid public key.
     #[allow(clippy::indexing_slicing)]
-    pub fn from_bytes(mut bytes: &[u8]) -> anyhow::Result<Self> {
+    pub fn from_bytes<R: Read>(reader: &mut R) -> anyhow::Result<Self> {
         let mut u8_buf = [0u8; 1];
         let mut u32_buf = [0u8; 4];
         let mut u64_buf = [0u8; 8];
         let mut u256_buf = [0u8; 32];
 
-        // Read tx size
-        bytes.read_exact(&mut u32_buf)?;
-        let tx_size = u32::from_be_bytes(u32_buf);
-        ensure!(
-            tx_size as usize == bytes.len(),
-            "Invalid tx size, expected: {tx_size}, provided: {0}.",
-            bytes.len()
-        );
+        // Skip tx size field
+        reader.read_exact(&mut u32_buf)?;
 
-        bytes.read_exact(&mut u8_buf)?;
+        reader.read_exact(&mut u8_buf)?;
         ensure!(
             u8_buf[0] == 0,
             "Invalid padding tag field value, must be equals to `0`, provided: {0}.",
             u8_buf[0]
         );
 
-        bytes.read_exact(&mut u8_buf)?;
+        reader.read_exact(&mut u8_buf)?;
         ensure!(
             u8_buf[0] == 11,
             "Invalid fragment tag field value, must be equals to `11`, provided: {0}.",
             u8_buf[0]
         );
 
-        bytes.read_exact(&mut u256_buf)?;
+        reader.read_exact(&mut u256_buf)?;
         let vote_plan_id = u256_buf;
 
-        bytes.read_exact(&mut u8_buf)?;
+        reader.read_exact(&mut u8_buf)?;
         let proposal_index = u8_buf[0];
 
-        bytes.read_exact(&mut u8_buf)?;
+        reader.read_exact(&mut u8_buf)?;
         let vote = match u8_buf[0] {
             1 => {
-                bytes.read_exact(&mut u8_buf)?;
+                reader.read_exact(&mut u8_buf)?;
                 Vote::Public(u8_buf[0])
             },
             2 => {
-                bytes.read_exact(&mut u8_buf)?;
-                let vote = EncryptedVote::from_bytes(bytes, u8_buf[0].into())
+                reader.read_exact(&mut u8_buf)?;
+                let vote = EncryptedVote::from_bytes(reader, u8_buf[0].into())
                     .map_err(|e| anyhow!("Invalid encrypted vote, error: {e}."))?;
-                bytes = &bytes[vote.bytes_size()..];
 
-                bytes.read_exact(&mut u8_buf)?;
-                let proof = VoterProof::from_bytes(bytes, u8_buf[0].into())
+                reader.read_exact(&mut u8_buf)?;
+                let proof = VoterProof::from_bytes(reader, u8_buf[0].into())
                     .map_err(|e| anyhow!("Invalid voter proof, error: {e}."))?;
-                bytes = &bytes[proof.bytes_size()..];
 
                 Vote::Private(vote, proof)
             },
             tag => bail!("Invalid vote tag value, must be equals to `0` or `1`, provided: {tag}"),
         };
 
         // skip block date (epoch and slot)
-        bytes.read_exact(&mut u64_buf)?;
+        reader.read_exact(&mut u64_buf)?;
 
-        bytes.read_exact(&mut u8_buf)?;
+        reader.read_exact(&mut u8_buf)?;
         ensure!(
             u8_buf[0] == 1,
             "Invalid number of inputs, expected: `1`, provided: {0}",
             u8_buf[0]
         );
 
-        bytes.read_exact(&mut u8_buf)?;
+        reader.read_exact(&mut u8_buf)?;
         ensure!(
             u8_buf[0] == 0,
             "Invalid number of outputs, expected: `0`, provided: {0}",
             u8_buf[0]
         );
 
-        bytes.read_exact(&mut u8_buf)?;
+        reader.read_exact(&mut u8_buf)?;
         ensure!(
             u8_buf[0] == 0xFF,
             "Invalid input tag, expected: `255`, provided: {0}",
             u8_buf[0]
         );
 
         // skip value
-        bytes.read_exact(&mut u64_buf)?;
+        reader.read_exact(&mut u64_buf)?;
 
-        bytes.read_exact(&mut u256_buf)?;
+        reader.read_exact(&mut u256_buf)?;
         let public_key = PublicKey::from_bytes(&u256_buf)
             .map_err(|e| anyhow!("Invalid public key, error: {e}."))?;
 
@@ -161,6 +154,8 @@ impl Tx {
 
 #[cfg(test)]
 mod tests {
+    use std::io::Cursor;
+
     use proptest::prelude::{any, any_with, Arbitrary, BoxedStrategy, Strategy};
     use test_strategy::proptest;
 
@@ -211,7 +206,12 @@ mod tests {
     #[allow(clippy::indexing_slicing)]
     fn tx_to_bytes_from_bytes_test(t1: Tx) {
         let bytes = t1.to_bytes();
-        let t2 = Tx::from_bytes(&bytes).unwrap();
+
+        // verify correctness serializing tx size field
+        let size = u32::from_be_bytes(bytes[0..4].try_into().unwrap());
+        assert_eq!(size as usize, bytes.len() - 4);
+
+        let t2 = Tx::from_bytes(&mut Cursor::new(bytes)).unwrap();
         assert_eq!(t1, t2);
     }
 }

rust/catalyst-voting/src/vote_protocol/voter/decoding.rs

@@ -17,12 +17,12 @@ impl EncryptedVote {
     ///
     /// # Errors
     ///   - Cannot decode ciphertext.
-    pub fn from_bytes(mut bytes: &[u8], size: usize) -> anyhow::Result<Self> {
+    pub fn from_bytes<R: Read>(reader: &mut R, size: usize) -> anyhow::Result<Self> {
         let mut ciph_buf = [0u8; Ciphertext::BYTES_SIZE];
 
         let ciphertexts = (0..size)
             .map(|i| {
-                bytes.read_exact(&mut ciph_buf)?;
+                reader.read_exact(&mut ciph_buf)?;
                 Ciphertext::from_bytes(&ciph_buf)
                     .map_err(|e| anyhow!("Cannot decode ciphertext at {i}, error: {e}"))
             })
@@ -64,14 +64,8 @@ impl VoterProof {
     ///   - Cannot decode ciphertext value.
     ///   - Cannot decode response randomness value.
     ///   - Cannot decode scalar value.
-    pub fn from_bytes(bytes: &[u8], len: usize) -> anyhow::Result<Self> {
-        UnitVectorProof::from_bytes(bytes, len).map(Self)
-    }
-
-    /// Get a deserialized bytes size
-    #[must_use]
-    pub fn bytes_size(&self) -> usize {
-        self.0.bytes_size()
+    pub fn from_bytes<R: Read>(reader: &mut R, len: usize) -> anyhow::Result<Self> {
+        UnitVectorProof::from_bytes(reader, len).map(Self)
     }
 
     /// Encode `EncryptedVote` tos bytes.
@@ -83,6 +77,8 @@ impl VoterProof {
 
 #[cfg(test)]
 mod tests {
+    use std::io::Cursor;
+
     use test_strategy::proptest;
 
     use super::*;
@@ -93,7 +89,7 @@ mod tests {
     ) {
         let bytes = vote1.to_bytes();
         assert_eq!(bytes.len(), vote1.bytes_size());
-        let vote2 = EncryptedVote::from_bytes(&bytes, vote1.size()).unwrap();
+        let vote2 = EncryptedVote::from_bytes(&mut Cursor::new(bytes), vote1.size()).unwrap();
         assert_eq!(vote1, vote2);
     }
 }