Merge remote-tracking branch 'origin/main' into feat/private-input-memory-mapped

Author: ColoCarletti

crypto/crypto/src/merkle_tree/backends/field_element_vector.rs

@@ -71,6 +71,23 @@ impl<F, D: Digest, const NUM_BYTES: usize> Default for FieldElementVectorBackend
     }
 }
 
+impl<F, D: Digest, const NUM_BYTES: usize> FieldElementVectorBackend<F, D, NUM_BYTES>
+where
+    [u8; NUM_BYTES]: From<Output<D>>,
+{
+    /// Hash raw bytes using the same digest (`D`) as this backend's leaf hashing.
+    /// Enables callers to pre-serialize field elements into a byte buffer and hash
+    /// once, avoiding per-element allocations while staying consistent with the
+    /// backend's hash function.
+    pub fn hash_bytes(data: &[u8]) -> [u8; NUM_BYTES] {
+        let mut hasher = D::new();
+        hasher.update(data);
+        let mut result = [0u8; NUM_BYTES];
+        result.copy_from_slice(&hasher.finalize());
+        result
+    }
+}
+
 impl<F, D: Digest, const NUM_BYTES: usize> IsMerkleTreeBackend
     for FieldElementVectorBackend<F, D, NUM_BYTES>
 where

crypto/math/src/fft/polynomial.rs

@@ -215,7 +215,7 @@ impl<E: IsField> Polynomial<FieldElement<E>> {
     ///
     /// Unlike [`coset_lde_full_into`], this skips the `clear + extend_from_slice` step
     /// since data is already in the buffer. Used for transpose elimination: columns are
-    /// extracted directly into pool buffers, then expanded in-place.
+    /// extracted directly into owned buffers, then expanded in-place.
     pub fn coset_lde_full_expand<F: IsFFTField + IsSubFieldOf<E> + Send + Sync>(
         buffer: &mut Vec<FieldElement<E>>,
         blowup_factor: usize,

crypto/math/src/field/extensions_goldilocks.rs

@@ -12,6 +12,8 @@ use crate::field::{
 use crate::traits::{AsBytes, ByteConversion};
 
 impl ByteConversion for [FpE; 2] {
+    const BYTE_LEN: usize = 16;
+
     #[cfg(feature = "alloc")]
     fn to_bytes_be(&self) -> alloc::vec::Vec<u8> {
         unimplemented!()
@@ -38,6 +40,8 @@ impl ByteConversion for [FpE; 2] {
 }
 
 impl ByteConversion for [FpE; 3] {
+    const BYTE_LEN: usize = 24;
+
     #[cfg(feature = "alloc")]
     fn to_bytes_be(&self) -> alloc::vec::Vec<u8> {
         let mut bytes = ByteConversion::to_bytes_be(&self[2]);
@@ -470,6 +474,17 @@ impl Fp3E {
 // =====================================================
 
 impl ByteConversion for FieldElement<Degree3GoldilocksExtensionField> {
+    const BYTE_LEN: usize = 24;
+
+    #[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]);
+        components[2].write_bytes_be(&mut buf[16..24]);
+    }
+
     #[cfg(feature = "alloc")]
     fn to_bytes_be(&self) -> alloc::vec::Vec<u8> {
         let mut byte_slice = ByteConversion::to_bytes_be(&self.value()[0]);
@@ -554,3 +569,27 @@ impl HasDefaultTranscript for Degree3GoldilocksExtensionField {
 fn mul_by_7(a: &FpE) -> FpE {
     FpE::from_raw(mul_by_7_raw(*a.value()))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::ByteConversion;
+
+    #[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());
+        }
+    }
+}

crypto/math/src/field/goldilocks.rs

@@ -434,6 +434,14 @@ impl GoldilocksElement {
 // =====================================================
 
 impl ByteConversion 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());
+    }
+
     #[cfg(feature = "alloc")]
     fn to_bytes_be(&self) -> alloc::vec::Vec<u8> {
         self.canonical_u64().to_be_bytes().to_vec()
@@ -543,3 +551,32 @@ impl HasDefaultTranscript for GoldilocksField {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::ByteConversion;
+
+    #[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/math/src/field/test_fields/u32_test_field.rs

@@ -11,6 +11,8 @@ use crate::traits::ByteConversion;
 pub struct U32Field<const MODULUS: u32>;
 
 impl ByteConversion for u32 {
+    const BYTE_LEN: usize = 4;
+
     #[cfg(feature = "alloc")]
     fn to_bytes_be(&self) -> alloc::vec::Vec<u8> {
         unimplemented!()

crypto/math/src/traits.rs

@@ -5,7 +5,10 @@ use crate::errors::ByteConversionError;
 /// for getting an element from its byte representation in big-endian or
 /// little-endian order.
 pub trait ByteConversion {
-    /// Returns the byte representation of the element in big-endian order.}
+    /// Byte length of the big-endian representation.
+    const BYTE_LEN: usize;
+
+    /// Returns the byte representation of the element in big-endian order.
     #[cfg(feature = "alloc")]
     fn to_bytes_be(&self) -> alloc::vec::Vec<u8>;
 
@@ -22,6 +25,14 @@ pub trait ByteConversion {
     fn from_bytes_le(bytes: &[u8]) -> Result<Self, ByteConversionError>
     where
         Self: Sized;
+
+    /// Write big-endian bytes into `buf[..BYTE_LEN]`.
+    /// Override for zero-allocation performance in hot paths.
+    #[cfg(feature = "alloc")]
+    fn write_bytes_be(&self, buf: &mut [u8]) {
+        let bytes = self.to_bytes_be();
+        buf[..bytes.len()].copy_from_slice(&bytes);
+    }
 }
 
 /// Serialize function without args
@@ -47,6 +58,8 @@ impl AsBytes for u64 {
 }
 
 impl ByteConversion for u64 {
+    const BYTE_LEN: usize = 8;
+
     #[cfg(feature = "alloc")]
     fn to_bytes_be(&self) -> alloc::vec::Vec<u8> {
         self.to_be_bytes().to_vec()

crypto/stark/src/instruments.rs

@@ -5,8 +5,6 @@ use std::time::Duration;
 /// Sub-operation timing breakdown for a single table in Rounds 2-4.
 #[derive(Clone, Debug, Default)]
 pub struct TableSubOps {
-    /// reconstruct_round1 (expand_pool_to_lde)
-    pub trace_lde: Duration,
     /// evaluator.evaluate()
     pub constraints: Duration,
     /// decompose_and_extend_d2
@@ -28,11 +26,11 @@ pub struct TableSubOps {
 /// Sub-operation breakdown for Round 1 aux commit pass.
 #[derive(Clone, Debug, Default)]
 pub struct Round1SubOps {
-    /// Main trace: expand_pool_to_lde (LDE/FFT)
+    /// Main trace: expand_columns_to_lde (LDE/FFT)
     pub main_lde: Duration,
     /// Main trace: commit_columns_bit_reversed (Merkle)
     pub main_merkle: Duration,
-    /// Aux trace: expand_pool_to_lde (LDE/FFT)
+    /// Aux trace: expand_columns_to_lde (LDE/FFT)
     pub aux_lde: Duration,
     /// Aux trace: commit_columns_bit_reversed (Merkle)
     pub aux_merkle: Duration,