feat(utils): Implement get_size_hint for default impls

math/src/field/f128/mod.rs

@@ -385,6 +385,10 @@ impl Serializable for BaseElement {
     fn write_into<W: ByteWriter>(&self, target: &mut W) {
         target.write_bytes(&self.0.to_le_bytes());
     }
+
+    fn get_size_hint(&self) -> usize {
+        self.0.get_size_hint()
+    }
 }
 
 impl Deserializable for BaseElement {

math/src/field/f62/mod.rs

@@ -512,6 +512,10 @@ impl Serializable for BaseElement {
         // convert from Montgomery representation into canonical representation
         target.write_bytes(&self.as_int().to_le_bytes());
     }
+
+    fn get_size_hint(&self) -> usize {
+        self.as_int().get_size_hint()
+    }
 }
 
 impl Deserializable for BaseElement {

math/src/field/f64/mod.rs

@@ -663,6 +663,10 @@ impl Serializable for BaseElement {
         // convert from Montgomery representation into canonical representation
         target.write_bytes(&self.as_int().to_le_bytes());
     }
+
+    fn get_size_hint(&self) -> usize {
+        self.as_int().get_size_hint()
+    }
 }
 
 impl Deserializable for BaseElement {

utils/core/src/serde/byte_writer.rs

@@ -77,7 +77,7 @@ pub trait ByteWriter: Sized {
     fn write_usize(&mut self, value: usize) {
         // convert the value into a u64 so that we always get 8 bytes from to_le_bytes() call
         let value = value as u64;
-        let length = encoded_len(value);
+        let length = usize_encoded_len(value);
 
         // 9-byte special case
         if length == 9 {
@@ -141,8 +141,8 @@ impl ByteWriter for alloc::vec::Vec<u8> {
 // HELPER FUNCTIONS
 // ================================================================================================
 
-/// Returns the length of the value in vint64 encoding.
-fn encoded_len(value: u64) -> usize {
+/// Returns the length of the usize value in vint64 encoding.
+pub(super) fn usize_encoded_len(value: u64) -> usize {
     let zeros = value.leading_zeros() as usize;
     let len = zeros.saturating_sub(1) / 7;
     9 - core::cmp::min(len, 8)

utils/core/src/serde/mod.rs

@@ -51,10 +51,18 @@ impl<T: Serializable> Serializable for &T {
     fn write_into<W: ByteWriter>(&self, target: &mut W) {
         (*self).write_into(target)
     }
+
+    fn get_size_hint(&self) -> usize {
+        (*self).get_size_hint()
+    }
 }
 
 impl Serializable for () {
     fn write_into<W: ByteWriter>(&self, _target: &mut W) {}
+
+    fn get_size_hint(&self) -> usize {
+        0
+    }
 }
 
 impl<T1> Serializable for (T1,)
@@ -64,6 +72,10 @@ where
     fn write_into<W: ByteWriter>(&self, target: &mut W) {
         self.0.write_into(target);
     }
+
+    fn get_size_hint(&self) -> usize {
+        self.0.get_size_hint()
+    }
 }
 
 impl<T1, T2> Serializable for (T1, T2)
@@ -75,6 +87,10 @@ where
         self.0.write_into(target);
         self.1.write_into(target);
     }
+
+    fn get_size_hint(&self) -> usize {
+        self.0.get_size_hint() + self.1.get_size_hint()
+    }
 }
 
 impl<T1, T2, T3> Serializable for (T1, T2, T3)
@@ -88,6 +104,10 @@ where
         self.1.write_into(target);
         self.2.write_into(target);
     }
+
+    fn get_size_hint(&self) -> usize {
+        self.0.get_size_hint() + self.1.get_size_hint() + self.2.get_size_hint()
+    }
 }
 
 impl<T1, T2, T3, T4> Serializable for (T1, T2, T3, T4)
@@ -103,6 +123,13 @@ where
         self.2.write_into(target);
         self.3.write_into(target);
     }
+
+    fn get_size_hint(&self) -> usize {
+        self.0.get_size_hint()
+            + self.1.get_size_hint()
+            + self.2.get_size_hint()
+            + self.3.get_size_hint()
+    }
 }
 
 impl<T1, T2, T3, T4, T5> Serializable for (T1, T2, T3, T4, T5)
@@ -120,6 +147,14 @@ where
         self.3.write_into(target);
         self.4.write_into(target);
     }
+
+    fn get_size_hint(&self) -> usize {
+        self.0.get_size_hint()
+            + self.1.get_size_hint()
+            + self.2.get_size_hint()
+            + self.3.get_size_hint()
+            + self.4.get_size_hint()
+    }
 }
 
 impl<T1, T2, T3, T4, T5, T6> Serializable for (T1, T2, T3, T4, T5, T6)
@@ -139,42 +174,75 @@ where
         self.4.write_into(target);
         self.5.write_into(target);
     }
+
+    fn get_size_hint(&self) -> usize {
+        self.0.get_size_hint()
+            + self.1.get_size_hint()
+            + self.2.get_size_hint()
+            + self.3.get_size_hint()
+            + self.4.get_size_hint()
+            + self.5.get_size_hint()
+    }
 }
 
 impl Serializable for u8 {
     fn write_into<W: ByteWriter>(&self, target: &mut W) {
         target.write_u8(*self);
     }
+
+    fn get_size_hint(&self) -> usize {
+        core::mem::size_of::<u8>()
+    }
 }
 
 impl Serializable for u16 {
     fn write_into<W: ByteWriter>(&self, target: &mut W) {
         target.write_u16(*self);
     }
+
+    fn get_size_hint(&self) -> usize {
+        core::mem::size_of::<u16>()
+    }
 }
 
 impl Serializable for u32 {
     fn write_into<W: ByteWriter>(&self, target: &mut W) {
         target.write_u32(*self);
     }
+
+    fn get_size_hint(&self) -> usize {
+        core::mem::size_of::<u32>()
+    }
 }
 
 impl Serializable for u64 {
     fn write_into<W: ByteWriter>(&self, target: &mut W) {
         target.write_u64(*self);
     }
+
+    fn get_size_hint(&self) -> usize {
+        core::mem::size_of::<u64>()
+    }
 }
 
 impl Serializable for u128 {
     fn write_into<W: ByteWriter>(&self, target: &mut W) {
         target.write_u128(*self);
     }
+
+    fn get_size_hint(&self) -> usize {
+        core::mem::size_of::<u128>()
+    }
 }
 
 impl Serializable for usize {
     fn write_into<W: ByteWriter>(&self, target: &mut W) {
         target.write_usize(*self)
     }
+
+    fn get_size_hint(&self) -> usize {
+        byte_writer::usize_encoded_len(*self as u64)
+    }
 }
 
 impl<T: Serializable> Serializable for Option<T> {
@@ -187,12 +255,24 @@ impl<T: Serializable> Serializable for Option<T> {
             None => target.write_bool(false),
         }
     }
+
+    fn get_size_hint(&self) -> usize {
+        core::mem::size_of::<bool>() + self.as_ref().map(|value| value.get_size_hint()).unwrap_or(0)
+    }
 }
 
 impl<T: Serializable, const C: usize> Serializable for [T; C] {
     fn write_into<W: ByteWriter>(&self, target: &mut W) {
         target.write_many(self)
     }
+
+    fn get_size_hint(&self) -> usize {
+        let mut size = 0;
+        for item in self {
+            size += item.get_size_hint();
+        }
+        size
+    }
 }
 
 impl<T: Serializable> Serializable for [T] {
@@ -202,41 +282,81 @@ impl<T: Serializable> Serializable for [T] {
             element.write_into(target);
         }
     }
+
+    fn get_size_hint(&self) -> usize {
+        let mut size = self.len().get_size_hint();
+        for element in self {
+            size += element.get_size_hint();
+        }
+        size
+    }
 }
 
 impl<T: Serializable> Serializable for Vec<T> {
     fn write_into<W: ByteWriter>(&self, target: &mut W) {
         target.write_usize(self.len());
         target.write_many(self);
     }
+
+    fn get_size_hint(&self) -> usize {
+        let mut size = self.len().get_size_hint();
+        for item in self {
+            size += item.get_size_hint();
+        }
+        size
+    }
 }
 
 impl<K: Serializable, V: Serializable> Serializable for BTreeMap<K, V> {
     fn write_into<W: ByteWriter>(&self, target: &mut W) {
         target.write_usize(self.len());
         target.write_many(self);
     }
+
+    fn get_size_hint(&self) -> usize {
+        let mut size = self.len().get_size_hint();
+        for item in self {
+            size += item.get_size_hint();
+        }
+        size
+    }
 }
 
 impl<T: Serializable> Serializable for BTreeSet<T> {
     fn write_into<W: ByteWriter>(&self, target: &mut W) {
         target.write_usize(self.len());
         target.write_many(self);
     }
+
+    fn get_size_hint(&self) -> usize {
+        let mut size = self.len().get_size_hint();
+        for item in self {
+            size += item.get_size_hint();
+        }
+        size
+    }
 }
 
 impl Serializable for str {
     fn write_into<W: ByteWriter>(&self, target: &mut W) {
         target.write_usize(self.len());
         target.write_many(self.as_bytes());
     }
+
+    fn get_size_hint(&self) -> usize {
+        self.len().get_size_hint() + self.as_bytes().len()
+    }
 }
 
 impl Serializable for String {
     fn write_into<W: ByteWriter>(&self, target: &mut W) {
         target.write_usize(self.len());
         target.write_many(self.as_bytes());
     }
+
+    fn get_size_hint(&self) -> usize {
+        self.len().get_size_hint() + self.as_bytes().len()
+    }
 }
 
 // DESERIALIZABLE