chore: modify return types to return unflattened structures

Author: kevaundray

bindings/csharp/csharp_code/PeerDASKZG.bindings/peerdaskzg.cs

@@ -58,7 +58,7 @@ public unsafe byte[] BlobToKzgCommitment(byte[] blob)
         return commitment;
     }
 
-    public unsafe byte[] ComputeCells(byte[] blob)
+    public unsafe byte[][] ComputeCells(byte[] blob)
     {
         byte[] cells = new byte[BytesForAllCells];
 
@@ -68,10 +68,10 @@ public unsafe byte[] ComputeCells(byte[] blob)
             CResult result = compute_cells(_context, Convert.ToUInt64(blob.Length), blobPtr, cellsPtr);
             ThrowOnError(result);
         }
-        return cells;
+        return DeflattenArray(cells, BytesPerCell);
     }
 
-    public unsafe (byte[], byte[]) ComputeCellsAndKZGProofs(byte[] blob)
+    public unsafe (byte[][], byte[][]) ComputeCellsAndKZGProofs(byte[] blob)
     {
         byte[] cells = new byte[BytesForAllCells];
         byte[] proofs = new byte[BytesForAllProofs];
@@ -83,7 +83,7 @@ public unsafe (byte[], byte[]) ComputeCellsAndKZGProofs(byte[] blob)
             CResult result = compute_cells_and_kzg_proofs(_context, Convert.ToUInt64(blob.Length), blobPtr, cellsPtr, proofsPtr);
             ThrowOnError(result);
         }
-        return (cells, proofs);
+        return (DeflattenArray(cells, BytesPerCell), DeflattenArray(proofs, BytesPerCommitment));
     }
 
     public unsafe bool VerifyCellKZGProof(byte[] cell, byte[] commitment, ulong cellId, byte[] proof)
@@ -125,7 +125,7 @@ public bool VerifyCellKZGProofBatch(byte[][] rowCommitments, ulong[] rowIndices,
         return verified;
     }
 
-    public byte[] RecoverAllCells(ulong[] cellIds, byte[][] cells)
+    public byte[][] RecoverAllCells(ulong[] cellIds, byte[][] cells)
     {
         byte[] cellsFlattened = FlattenArray(cells);
 
@@ -138,7 +138,7 @@ public byte[] RecoverAllCells(ulong[] cellIds, byte[][] cells)
             ThrowOnError(result);
         }
 
-        return recoveredCells;
+        return DeflattenArray(recoveredCells, BytesPerCell);
     }
 
     private static void ThrowOnError(CResult result)
@@ -167,7 +167,7 @@ private static void ThrowOnError(CResult result)
         }
     }
 
-    public static byte[] FlattenArray(byte[][] jaggedArray)
+    private static byte[] FlattenArray(byte[][] jaggedArray)
     {
         int totalLength = 0;
 
@@ -192,6 +192,20 @@ public static byte[] FlattenArray(byte[][] jaggedArray)
         return flattenedArray;
     }
 
+    private static byte[][] DeflattenArray(byte[] flattenedArray, int length)
+    {
+        int numArrays = flattenedArray.Length / length;
+        byte[][] jaggedArray = new byte[numArrays][];
+
+        for (int i = 0; i < numArrays; i++)
+        {
+            jaggedArray[i] = new byte[length];
+            Array.Copy(flattenedArray, i * length, jaggedArray[i], 0, length);
+        }
+
+        return jaggedArray;
+    }
+
     public enum ContextSetting
     {
         ProvingOnly,

bindings/csharp/csharp_code/PeerDASKZG.test/RefTests.cs

@@ -47,21 +47,6 @@ private static byte[] GetBytes(string hex)
         return Convert.FromHexString(hex[2..]);
     }
 
-    private static byte[] GetFlatBytes(List<string> strings)
-    {
-        List<byte[]> stringBytes = strings.Select(GetBytes).ToList();
-
-        byte[] flatBytes = new byte[stringBytes.Sum(b => b.Length)];
-        int offset = 0;
-        foreach (byte[] bytes in stringBytes)
-        {
-            Buffer.BlockCopy(bytes, 0, flatBytes, offset, bytes.Length);
-            offset += bytes.Length;
-        }
-
-        return flatBytes;
-    }
-
     private static byte[][] GetByteArrays(List<string> strings)
     {
         return strings.Select(GetBytes).ToArray();
@@ -146,14 +131,14 @@ public void TestComputeCells()
             ComputeCellsTest test = _deserializer.Deserialize<ComputeCellsTest>(yaml);
             Assert.That(test, Is.Not.EqualTo(null));
 
-            byte[] cells;
+            byte[][] cells;
             byte[] blob = GetBytes(test.Input.Blob);
 
             try
             {
                 cells = _context.ComputeCells(blob);
                 Assert.That(test.Output, Is.Not.EqualTo(null));
-                byte[] expectedCells = GetFlatBytes(test.Output);
+                byte[][] expectedCells = GetByteArrays(test.Output);
                 Assert.That(cells, Is.EqualTo(expectedCells));
             }
             catch
@@ -197,11 +182,11 @@ public void TestComputeCellsAndKzgProofs()
 
             try
             {
-                (byte[] cells, byte[] proofs) = _context.ComputeCellsAndKZGProofs(blob);
+                (byte[][] cells, byte[][] proofs) = _context.ComputeCellsAndKZGProofs(blob);
                 Assert.That(test.Output, Is.Not.EqualTo(null));
-                byte[] expectedCells = GetFlatBytes(test.Output.ElementAt(0));
+                byte[][] expectedCells = GetByteArrays(test.Output.ElementAt(0));
                 Assert.That(cells, Is.EqualTo(expectedCells));
-                byte[] expectedProofs = GetFlatBytes(test.Output.ElementAt(1));
+                byte[][] expectedProofs = GetByteArrays(test.Output.ElementAt(1));
                 Assert.That(proofs, Is.EqualTo(expectedProofs));
             }
             catch
@@ -352,9 +337,9 @@ public void TestRecoverAllCells()
 
             try
             {
-                byte[] recoveredCells = _context.RecoverAllCells(cellIds, cells);
+                byte[][] recoveredCells = _context.RecoverAllCells(cellIds, cells);
                 Assert.That(test.Output, Is.Not.EqualTo(null));
-                byte[] expectedRecoveredCells = GetFlatBytes(test.Output);
+                byte[][] expectedRecoveredCells = GetByteArrays(test.Output);
                 Assert.That(recoveredCells, Is.EqualTo(expectedRecoveredCells));
             }
             catch