From 5ecbb60e9fed36c564e90fe4df71f20134d5d4e9 Mon Sep 17 00:00:00 2001
From: danielSanchezQ <3danimanimal@gmail.com>
Date: Fri, 24 Jan 2025 14:50:02 +0000
Subject: [PATCH] Fix calls

---
 da/encoder.py      | 22 +++++++++++++++-------
 da/test_encoder.py | 23 +++++++++++++++++------
 2 files changed, 32 insertions(+), 13 deletions(-)

diff --git a/da/encoder.py b/da/encoder.py
index 1170803..a08b4ab 100644
--- a/da/encoder.py
+++ b/da/encoder.py
@@ -86,11 +86,11 @@ class DAEncoder:
 
     @staticmethod
     def _compute_aggregated_column_commitment(
-        chunks_matrix: ChunksMatrix, column_commitments: Sequence[Commitment]
+        column_commitments: Sequence[Commitment]
     ) -> Tuple[Polynomial, Commitment]:
         data = bytes(chain.from_iterable(
-            DAEncoder.hash_commitment_blake2b31(column, commitment)
-            for column, commitment in zip(chunks_matrix.columns, column_commitments)
+            DAEncoder.hash_commitment_blake2b31(commitment)
+            for commitment in column_commitments
         ))
         return kzg.bytes_to_commitment(data, GLOBAL_PARAMETERS)
 
@@ -108,9 +108,14 @@ class DAEncoder:
         chunks_matrix = self._chunkify_data(data)
         row_polynomials, row_commitments = zip(*self._compute_row_kzg_commitments(chunks_matrix))
         extended_matrix = self._rs_encode_rows(chunks_matrix)
-        h = derive_challenge(row_commitments)
-        combined_poly = compute_combined_polynomial(row_polynomials, h)
-        combined_column_proofs = self._compute_combined_column_proofs(combined_poly)
+        row_proofs = self._compute_rows_proofs(extended_matrix, row_polynomials, row_commitments)
+        column_polynomials, column_commitments = zip(*self._compute_column_kzg_commitments(extended_matrix))
+        aggregated_column_polynomial, aggregated_column_commitment = (
+            self._compute_aggregated_column_commitment(column_commitments)
+        )
+        aggregated_column_proofs = self._compute_aggregated_column_proofs(
+            aggregated_column_polynomial, column_commitments
+        )
         result = EncodedData(
             data,
             chunks_matrix,
@@ -122,4 +127,7 @@ class DAEncoder:
 
     @staticmethod
     def hash_commitment_blake2b31(commitment: Commitment) -> bytes:
-        return blake2b(bytes(commitment), digest_size=31).digest()
+        return (
+            # digest size must be 31 bytes as we cannot encode 32 without risking overflowing the BLS_MODULUS
+            int.from_bytes(blake2b(bytes(commitment), digest_size=31).digest())
+        ).to_bytes(32, byteorder="big") # rewrap into 32 padded bytes for the field elements, EC library dependant
\ No newline at end of file
diff --git a/da/test_encoder.py b/da/test_encoder.py
index 5583300..9d40627 100644
--- a/da/test_encoder.py
+++ b/da/test_encoder.py
@@ -87,12 +87,23 @@ class TestEncoder(TestCase):
 
     def test_generate_combined_column_proofs(self):
         chunks_matrix = self.encoder._chunkify_data(self.data)
-        row_polynomials, row_commitments = zip(*self.encoder._compute_row_kzg_commitments(chunks_matrix))
-        h = derive_challenge(row_commitments)
-        combined_poly = compute_combined_polynomial(row_polynomials, h)
-        proofs = self.encoder._compute_combined_column_proofs(combined_poly)
-        expected_extended_columns = self.params.column_count * 2
-        self.assertEqual(len(proofs), expected_extended_columns)
+        polynomials, commitments = zip(*self.encoder._compute_column_kzg_commitments(chunks_matrix))
+        self.assertEqual(len(commitments), len(chunks_matrix[0]))
+        self.assertEqual(len(polynomials), len(chunks_matrix[0]))
+
+    def test_generate_aggregated_column_commitments(self):
+        chunks_matrix = self.encoder._chunkify_data(self.data)
+        _, column_commitments = zip(*self.encoder._compute_column_kzg_commitments(chunks_matrix))
+        poly, commitment = self.encoder._compute_aggregated_column_commitment(column_commitments)
+        self.assertIsNotNone(poly)
+        self.assertIsNotNone(commitment)
+
+    def test_generate_aggregated_column_proofs(self):
+        chunks_matrix = self.encoder._chunkify_data(self.data)
+        _, column_commitments = zip(*self.encoder._compute_column_kzg_commitments(chunks_matrix))
+        poly, _ = self.encoder._compute_aggregated_column_commitment(column_commitments)
+        proofs = self.encoder._compute_aggregated_column_proofs(poly, column_commitments)
+        self.assertEqual(len(proofs), len(column_commitments))
 
     def test_encode(self):
         from random import randbytes