refactor(workspace): clean up

Author: mempirate

src/common.rs

@@ -1,11 +1,11 @@
 use thiserror::Error;
 
+use crate::primitives::ChunksError;
+
 #[derive(Error, Debug)]
 pub enum RLNCError {
-    #[error("Data is empty")]
-    EmptyData,
-    #[error("Chunk count must be greater than 0")]
-    ZeroChunkCount,
+    #[error(transparent)]
+    ChunksError(#[from] ChunksError),
     #[error("Required packet count must be greater than 0")]
     ZeroPacketCount,
     #[error("Chunk size mismatch: got {0}, expected {1}")]

src/decode.rs

@@ -3,7 +3,7 @@
 use crate::{
     common::RLNCError,
     matrix::Matrix,
-    primitives::{field::Field, packet::RLNCPacket},
+    primitives::{ChunksError, field::Field, packet::RLNCPacket},
 };
 
 /// RLNC Decoder.
@@ -23,7 +23,7 @@ impl<F: Field> Decoder<F> {
     /// Creates a new decoder for the given chunk size and chunk count (generation size).
     pub fn new(chunk_size: usize, chunk_count: usize) -> Result<Self, RLNCError> {
         if chunk_size == 0 {
-            return Err(RLNCError::ZeroChunkCount);
+            return Err(ChunksError::ZeroChunkSize.into());
         }
 
         if chunk_count == 0 {

src/encode.rs

@@ -2,19 +2,16 @@
 use rand::Rng;
 
 use crate::{
-    common::{BOUNDARY_MARKER, RLNCError},
-    primitives::{
-        Chunk,
-        field::{Field, Scalar},
-        packet::RLNCPacket,
-    },
+    common::RLNCError,
+    primitives::{Chunks, field::Field, packet::RLNCPacket},
 };
 
-/// RLNC encoder.
+/// RLNC encoder that's generic over the [`Field`] type. An ancoder should be instantiated
+/// per piece of data the caller wants to encode, then used to generate the encoded chunks.
 #[derive(Debug)]
 pub struct Encoder<F: Field> {
     // The chunks of data to be encoded.
-    chunks: Vec<Chunk<F>>,
+    chunks: Chunks<F>,
     // The number of chunks to split the data into (also known as the generation size).
     chunk_count: usize,
     // The size of each chunk in bytes.
@@ -23,43 +20,18 @@ pub struct Encoder<F: Field> {
 
 impl<F: Field> Encoder<F> {
     /// Creates a new encoder for the given data and chunk count.
-    ///
-    /// # Arguments
-    ///
-    /// - `data` - The data to be encoded.
-    /// - `chunk_count` - The number of chunks to split the data into (also known as the generation
-    ///   size).
     pub fn new(data: impl AsRef<[u8]>, chunk_count: usize) -> Result<Self, RLNCError> {
-        if data.as_ref().is_empty() {
-            return Err(RLNCError::EmptyData);
-        }
-
-        if chunk_count == 0 {
-            return Err(RLNCError::ZeroChunkCount);
-        }
-
-        let mut data = Vec::from(data.as_ref());
-        data.push(BOUNDARY_MARKER);
-
-        // Calculate chunk size to accommodate original data + boundary marker
-        let chunk_size = data.len().div_ceil(chunk_count);
-
-        // Round up chunk size to nearest multiple of `F::SAFE_CAPACITY` for scalar packing
-        let chunk_size = chunk_size.div_ceil(F::SAFE_CAPACITY) * F::SAFE_CAPACITY;
-        let padded_len = chunk_size * chunk_count;
-
-        // Pad the rest with zeros if needed
-        data.resize(padded_len, 0);
-
-        let chunks = data.chunks_exact(chunk_size).map(Chunk::from_bytes).collect();
+        let chunks = Self::prepare(data, chunk_count)?;
+        let chunk_count = chunks.len();
+        let chunk_size = chunks.chunk_size();
 
         Ok(Self { chunks, chunk_count, chunk_size })
     }
 
     /// Creates a new encoder from a vector of chunks.
-    pub fn from_chunks(chunks: Vec<Chunk<F>>) -> Self {
+    pub fn from_chunks(chunks: Chunks<F>) -> Self {
         let chunk_count = chunks.len();
-        let chunk_size = chunks[0].size();
+        let chunk_size = chunks.chunk_size();
 
         Self { chunks, chunk_count, chunk_size }
     }
@@ -88,7 +60,7 @@ impl<F: Field> Encoder<F> {
     fn encode_inner(&self, coding_vector: &[F]) -> Vec<F> {
         let mut result = vec![F::ZERO; self.chunk_size.div_ceil(F::SAFE_CAPACITY)];
 
-        for (chunk, &coefficient) in self.chunks.iter().zip(coding_vector) {
+        for (chunk, &coefficient) in self.chunks.inner().iter().zip(coding_vector) {
             if coefficient.is_zero_vartime() {
                 continue;
             }
@@ -113,32 +85,8 @@ impl<F: Field> Encoder<F> {
 
     /// Prepares the data for encoding by splitting it into equally sized chunks and padding with
     /// zeros. Also converts the data into symbols in the chosen finite field.
-    pub fn prepare(
-        data: impl AsRef<[u8]>,
-        chunk_count: usize,
-    ) -> Result<Vec<Chunk<Scalar>>, RLNCError> {
-        if data.as_ref().is_empty() {
-            return Err(RLNCError::EmptyData);
-        }
-
-        if chunk_count == 0 {
-            return Err(RLNCError::ZeroChunkCount);
-        }
-
-        let mut data = Vec::from(data.as_ref());
-        data.push(BOUNDARY_MARKER);
-
-        // Calculate chunk size to accommodate original data + boundary marker
-        let chunk_size = data.len().div_ceil(chunk_count);
-
-        // Round up chunk size to nearest multiple of `F::SAFE_CAPACITY` for scalar packing
-        let chunk_size = chunk_size.div_ceil(F::SAFE_CAPACITY) * F::SAFE_CAPACITY;
-        let padded_len = chunk_size * chunk_count;
-
-        // Pad the rest with zeros if needed
-        data.resize(padded_len, 0);
-
-        Ok(data.chunks_exact(chunk_size).map(Chunk::from_bytes).collect())
+    pub fn prepare(data: impl AsRef<[u8]>, chunk_count: usize) -> Result<Chunks<F>, RLNCError> {
+        Ok(Chunks::new(data.as_ref(), chunk_count)?)
     }
 
     /// Encodes the data with the given coding vector using linear combinations.
@@ -189,6 +137,7 @@ impl<F: Field> Encoder<F> {
                 // Map each (chunk, coefficient) pair to its contribution and then reduce all
                 // contributions into the final result.
                 self.chunks
+                    .inner()
                     .par_iter()
                     .zip(coding_vector)
                     .filter_map(|(chunk, &coefficient)| {

src/lib.rs

@@ -69,11 +69,12 @@ mod tests {
 
         let chunks = Encoder::<Scalar>::prepare(&data, chunk_count).unwrap();
         let start = Instant::now();
-        let committer = PedersenCommitter::new(seed, chunks[0].symbols().len());
+        let committer = PedersenCommitter::new(seed, chunks.inner()[0].symbols().len());
         println!("Committer creation time: {:?}", start.elapsed());
 
         let start = Instant::now();
-        let commitments = chunks.iter().map(|c| committer.commit(c.symbols())).collect::<Vec<_>>();
+        let commitments =
+            chunks.inner().iter().map(|c| committer.commit(c.symbols())).collect::<Vec<_>>();
         println!("Commitment time: {:?}", start.elapsed());
 
         let encoder = Encoder::from_chunks(chunks);

src/primitives/mod.rs

@@ -3,10 +3,87 @@ pub mod field;
 pub mod packet;
 use field::Field;
 
+use crate::common::BOUNDARY_MARKER;
+
+/// A collection of equally sized, prepared chunks of data. Each chunk of data holds the symbols.
+/// This type represents correctly sized and padded chunks of data that are ready to be encoded.
+#[derive(Debug)]
+pub struct Chunks<F: Field> {
+    inner: Vec<Chunk<F>>,
+    chunk_size: usize,
+}
+
+/// Errors that can occur when creating a new collection of chunks.
+#[derive(Debug, thiserror::Error)]
+pub enum ChunksError {
+    /// The data is empty.
+    #[error("data is empty")]
+    EmptyData,
+    /// The chunk count is zero.
+    #[error("chunk count is zero")]
+    ZeroChunkCount,
+    /// The chunk size is zero.
+    #[error("chunk size is zero")]
+    ZeroChunkSize,
+}
+
+impl<F: Field> Chunks<F> {
+    /// Creates a new collection of chunks from a slice of bytes. The data is split into
+    /// `chunk_count` equally sized chunks, and then converted into symbols (scalars) of the
+    /// field `F`. See also [`Chunk`] for more details.
+    pub fn new(data: &[u8], chunk_count: usize) -> Result<Self, ChunksError> {
+        if data.is_empty() {
+            return Err(ChunksError::EmptyData);
+        }
+
+        if chunk_count == 0 {
+            return Err(ChunksError::ZeroChunkCount);
+        }
+
+        let mut data = Vec::from(data.as_ref());
+        data.push(BOUNDARY_MARKER);
+
+        // Calculate chunk size to accommodate original data + boundary marker
+        let chunk_size = data.len().div_ceil(chunk_count);
+
+        // Round up chunk size to nearest multiple of `F::SAFE_CAPACITY` for scalar packing
+        let chunk_size = chunk_size.div_ceil(F::SAFE_CAPACITY) * F::SAFE_CAPACITY;
+        let padded_len = chunk_size * chunk_count;
+
+        // Pad the rest with zeros if needed
+        data.resize(padded_len, 0);
+
+        let chunks = data.chunks_exact(chunk_size).map(Chunk::from_bytes).collect();
+
+        Ok(Self { inner: chunks, chunk_size })
+    }
+
+    /// Returns the size of the chunks in bytes.
+    pub fn chunk_size(&self) -> usize {
+        self.chunk_size
+    }
+
+    /// Returns the inner chunks.
+    pub fn inner(&self) -> &[Chunk<F>] {
+        &self.inner
+    }
+
+    /// Returns the number of chunks in the collection.
+    pub fn len(&self) -> usize {
+        self.inner.len()
+    }
+
+    /// Returns true if the collection is empty.
+    pub fn is_empty(&self) -> bool {
+        self.inner.is_empty()
+    }
+}
+
 /// A chunk of data.
 #[derive(Debug, Clone)]
 pub struct Chunk<F: Field> {
     symbols: Vec<F>,
+    #[allow(unused)]
     size: usize,
 }
 
@@ -22,12 +99,4 @@ impl<F: Field> Chunk<F> {
     pub(crate) fn symbols(&self) -> &[F] {
         &self.symbols
     }
-
-    /// Returns the size of the chunk in bytes.
-    pub(crate) fn size(&self) -> usize {
-        self.size
-    }
 }
-
-// TODO: Add a generic implementation for Chunk<S>. In its current form, we have to convert bytes to
-// Symbols, but since ff::Field doesn't implement TryFrom<&[u8]>, we can't make it generic.