Implement rs encode rows test

Fix related bugs
Refactored API

nomos-da/kzgrs-backend/src/common.rs

@@ -78,6 +78,10 @@ impl ChunksMatrix {
     pub fn transposed(&self) -> Self {
         Self(self.columns().map(|c| Row(c.0)).collect())
     }
+
+    pub fn iter(&self) -> impl Iterator<Item = &Row> {
+        self.0.iter()
+    }
 }
 
 impl FromIterator<Row> for ChunksMatrix {

nomos-da/kzgrs-backend/src/encoder.rs

@@ -31,7 +31,7 @@ pub struct EncodedData {
     aggregated_column_proofs: Vec<Proof>,
 }
 
-struct DaEncoder {
+pub struct DaEncoder {
     params: DaEncoderParams,
 }
 
@@ -77,7 +77,7 @@ impl DaEncoder {
     }
 
     fn rs_encode_row(evaluations: &Evaluations, row: &Polynomial) -> Evaluations {
-        encode(row, evaluations, 2, &DOMAIN)
+        encode(row, evaluations, 2, *DOMAIN)
     }
 
     fn rs_encode_rows(rows: &[(Evaluations, Polynomial)]) -> Vec<Evaluations> {
@@ -196,7 +196,9 @@ impl DaEncoder {
 #[cfg(test)]
 pub mod test {
     use crate::encoder::{DaEncoder, DaEncoderParams};
-    use kzgrs::BYTES_PER_FIELD_ELEMENT;
+    use crate::global::DOMAIN;
+    use kzgrs::common::bytes_to_polynomial_unchecked;
+    use kzgrs::{decode, BYTES_PER_FIELD_ELEMENT};
     use rand::RngCore;
     use std::ops::Div;
 
@@ -230,4 +232,26 @@ pub mod test {
         let commitments_data = DaEncoder::compute_kzg_row_commitments(&matrix).unwrap();
         assert_eq!(commitments_data.len(), matrix.len());
     }
+
+    #[test]
+    fn test_rs_encode_rows() {
+        let data = rand_data(32);
+        let matrix = ENCODER.chunkify(data.as_ref());
+        let (poly_data, _): (Vec<_>, Vec<_>) = DaEncoder::compute_kzg_row_commitments(&matrix)
+            .unwrap()
+            .into_iter()
+            .unzip();
+        let extended_rows = DaEncoder::rs_encode_rows(&poly_data);
+        let extended_matrix = DaEncoder::evals_to_chunk_matrix(&extended_rows);
+        for ((r1, r2), evals) in matrix.iter().zip(extended_matrix.iter()).zip(extended_rows) {
+            assert_eq!(r1.len(), r2.len().div(2));
+            let points: Vec<_> = evals.evals.iter().cloned().map(Some).collect();
+            let poly_2 = decode(r1.len(), &points, *DOMAIN);
+            let (poly_1, _) = bytes_to_polynomial_unchecked::<BYTES_PER_FIELD_ELEMENT>(
+                r1.as_bytes().as_ref(),
+                *DOMAIN,
+            );
+            assert_eq!(poly_1, poly_2);
+        }
+    }
 }

nomos-da/kzgrs/src/rs.rs

@@ -14,14 +14,14 @@ pub fn encode(
     polynomial: &DensePolynomial<Fr>,
     evaluations: &Evaluations<Fr>,
     factor: usize,
-    domain: &GeneralEvaluationDomain<Fr>,
+    domain: GeneralEvaluationDomain<Fr>,
 ) -> Evaluations<Fr> {
     assert!(factor > 1);
     Evaluations::from_vec_and_domain(
         (0..evaluations.evals.len() * factor)
             .map(|i| polynomial.evaluate(&domain.element(i)))
             .collect(),
-        *domain,
+        domain,
     )
 }
 
@@ -31,7 +31,7 @@ pub fn encode(
 pub fn decode(
     original_chunks_len: usize,
     points: &[Option<Fr>],
-    domain: &GeneralEvaluationDomain<Fr>,
+    domain: GeneralEvaluationDomain<Fr>,
 ) -> Evaluations<Fr> {
     let (points, roots_of_unity): (Vec<Fr>, Vec<Fr>) = points
         .iter()
@@ -49,7 +49,7 @@ pub fn decode(
         (0..original_chunks_len)
             .map(|i| coeffs.evaluate(&domain.element(i)))
             .collect(),
-        *domain,
+        domain,
     )
 }