add debug_asserts, fix comments, remove dead code, add tests

Author: nicole-graus

crypto/math/src/field/extensions_goldilocks.rs

@@ -528,6 +528,7 @@ impl crate::traits::WriteBytes for FieldElement<Degree3GoldilocksExtensionField>
     const BYTE_LEN: usize = 24; // 3 × 8 bytes
     #[inline(always)]
     fn write_bytes_be(&self, buf: &mut [u8]) {
+        debug_assert!(buf.len() >= 24);
         let components = self.value();
         components[0].write_bytes_be(&mut buf[0..8]);
         components[1].write_bytes_be(&mut buf[8..16]);
@@ -555,6 +556,30 @@ impl HasDefaultTranscript for Degree3GoldilocksExtensionField {
     }
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::WriteBytes;
+
+    #[test]
+    fn write_bytes_be_matches_as_bytes() {
+        let cases = [
+            FieldElement::<Degree3GoldilocksExtensionField>::zero(),
+            FieldElement::<Degree3GoldilocksExtensionField>::one(),
+            FieldElement::<Degree3GoldilocksExtensionField>::new([
+                FpE::from(1u64),
+                FpE::from(2u64),
+                FpE::from(3u64),
+            ]),
+        ];
+        for elem in &cases {
+            let mut buf = [0u8; 24];
+            elem.write_bytes_be(&mut buf);
+            assert_eq!(&buf[..], elem.as_bytes().as_slice());
+        }
+    }
+}
+
 // =====================================================
 // HELPER FUNCTIONS
 // =====================================================

crypto/math/src/field/goldilocks.rs

@@ -486,6 +486,7 @@ impl crate::traits::WriteBytes for FieldElement<GoldilocksField> {
     const BYTE_LEN: usize = 8;
     #[inline(always)]
     fn write_bytes_be(&self, buf: &mut [u8]) {
+        debug_assert!(buf.len() >= 8);
         buf[..8].copy_from_slice(&self.canonical_u64().to_be_bytes());
     }
 }
@@ -551,3 +552,32 @@ impl HasDefaultTranscript for GoldilocksField {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::WriteBytes;
+
+    #[test]
+    fn write_bytes_be_matches_as_bytes() {
+        let cases = [
+            FieldElement::<GoldilocksField>::from(0u64),
+            FieldElement::<GoldilocksField>::from(1u64),
+            FieldElement::<GoldilocksField>::from(GOLDILOCKS_PRIME - 1),
+        ];
+        for elem in &cases {
+            let mut buf = [0u8; 8];
+            elem.write_bytes_be(&mut buf);
+            assert_eq!(&buf[..], elem.as_bytes().as_slice());
+        }
+    }
+
+    #[test]
+    fn write_bytes_be_matches_as_bytes_noncanonical() {
+        // Values stored as-is via from_raw are non-canonical (>= p) until serialized.
+        let elem = FieldElement::<GoldilocksField>::from_raw(GOLDILOCKS_PRIME + 5);
+        let mut buf = [0u8; 8];
+        elem.write_bytes_be(&mut buf);
+        assert_eq!(&buf[..], elem.as_bytes().as_slice());
+    }
+}

crypto/stark/src/prover.rs

@@ -358,20 +358,6 @@ pub trait IsStarkProver<
     FieldElement<Field>: math::traits::WriteBytes,
     FieldElement<FieldExtension>: math::traits::WriteBytes,
 {
-    /// Returns the Merkle tree and the commitment to the vectors `vectors`.
-    fn batch_commit_extension(
-        vectors: &[Vec<FieldElement<FieldExtension>>],
-    ) -> Option<(BatchedMerkleTree<FieldExtension>, Commitment)>
-    where
-        FieldElement<Field>: AsBytes + Sync + Send,
-        FieldElement<FieldExtension>: AsBytes + Sync + Send,
-    {
-        let tree = BatchedMerkleTree::build(vectors)?;
-
-        let commitment = tree.root;
-        Some((tree, commitment))
-    }
-
     /// Builds a Merkle tree commitment from column-major LDE evaluations with
     /// bit-reverse permutation, without cloning the full evaluation matrix.
     ///
@@ -402,8 +388,8 @@ pub trait IsStarkProver<
         #[cfg(not(feature = "parallel"))]
         let iter = 0..num_rows;
 
-        // Zero per-element heap allocations: write bytes directly from columns
-        // into a per-row buffer, then hash once.
+        // One allocation per row (was one per field element): write all columns
+        // into a single buffer, then hash once.
         let hashed_leaves: Vec<Commitment> = iter
             .map(|row_idx| {
                 let br_idx = reverse_index(row_idx, num_rows as u64);
@@ -727,8 +713,8 @@ pub trait IsStarkProver<
 
         let byte_len = <FieldElement<FieldExtension> as WriteBytes>::BYTE_LEN;
 
-        // Zero per-element allocations: write bytes directly from column data.
-        // Each leaf = row_pair[2*i] ++ row_pair[2*i+1] after bit-reverse.
+        // One allocation per leaf (was one per field element): write all parts
+        // into a single buffer. Each leaf = row_pair[2*i] ++ row_pair[2*i+1] after bit-reverse.
         #[cfg(feature = "parallel")]
         let iter = (0..num_leaves).into_par_iter();
         #[cfg(not(feature = "parallel"))]