feat: improve non-human-readable felt serialization space efficiency (#155)

Co-authored-by: Gabriel Bosio <[email protected]>

Author: tdelabro

crates/starknet-types-core/Cargo.toml

@@ -66,6 +66,7 @@ rand_chacha = "0.9"
 rand = "0.9.2"
 rstest = "0.24"
 lazy_static = { version = "1.5", default-features = false }
+bincode = "1"
 
 [[bench]]
 name = "criterion_hashes"

crates/starknet-types-core/src/felt/serde.rs

@@ -6,7 +6,10 @@ use core::fmt;
 use lambdaworks_math::field::{
     element::FieldElement, fields::fft_friendly::stark_252_prime_field::Stark252PrimeField,
 };
-use serde::{de, Deserialize, Serialize};
+use serde::{
+    de::{self},
+    Deserialize, Serialize,
+};
 
 use super::Felt;
 
@@ -18,7 +21,9 @@ impl Serialize for Felt {
         if serializer.is_human_readable() {
             serializer.serialize_str(&format!("{:#x}", self))
         } else {
-            serializer.serialize_bytes(&self.to_bytes_be())
+            let be_bytes = self.to_bytes_be();
+            let first_significant_byte_index = be_bytes.iter().position(|&b| b != 0).unwrap_or(31);
+            serializer.serialize_bytes(&be_bytes[first_significant_byte_index..])
         }
     }
 }
@@ -66,21 +71,25 @@ impl de::Visitor<'_> for FeltVisitor {
     where
         E: de::Error,
     {
-        match value.try_into() {
-            Ok(v) => Ok(Felt::from_bytes_be(&v)),
-            _ => Err(de::Error::invalid_length(value.len(), &self)),
+        if value.len() > 32 {
+            return Err(de::Error::invalid_length(value.len(), &self));
         }
+
+        let mut buffer = [0u8; 32];
+        buffer[32 - value.len()..].copy_from_slice(value);
+        Ok(Felt::from_bytes_be(&buffer))
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use bincode::Options;
+    use proptest::prelude::*;
+    use serde_test::{assert_tokens, Configure, Token};
 
     #[test]
     fn serde() {
-        use serde_test::{assert_tokens, Configure, Token};
-
         assert_tokens(&Felt::ZERO.readable(), &[Token::String("0x0")]);
         assert_tokens(&Felt::TWO.readable(), &[Token::String("0x2")]);
         assert_tokens(&Felt::THREE.readable(), &[Token::String("0x3")]);
@@ -91,21 +100,48 @@ mod tests {
             )],
         );
 
-        assert_tokens(&Felt::ZERO.compact(), &[Token::Bytes(&[0; 32])]);
-        static TWO: [u8; 32] = [
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 2,
-        ];
-        assert_tokens(&Felt::TWO.compact(), &[Token::Bytes(&TWO)]);
-        static THREE: [u8; 32] = [
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 3,
-        ];
-        assert_tokens(&Felt::THREE.compact(), &[Token::Bytes(&THREE)]);
+        assert_tokens(&Felt::ZERO.compact(), &[Token::Bytes(&[0; 1])]);
+        assert_tokens(&Felt::TWO.compact(), &[Token::Bytes(&[2])]);
+        assert_tokens(&Felt::THREE.compact(), &[Token::Bytes(&[3])]);
         static MAX: [u8; 32] = [
             8, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0,
         ];
         assert_tokens(&Felt::MAX.compact(), &[Token::Bytes(&MAX)]);
+        assert_tokens(
+            &Felt::from_hex_unchecked("0xbabe").compact(),
+            &[Token::Bytes(&[0xba, 0xbe])],
+        );
+        assert_tokens(
+            &Felt::from_hex_unchecked("0xba000000be").compact(),
+            &[Token::Bytes(&[0xba, 0, 0, 0, 0xbe])],
+        );
+        assert_tokens(
+            &Felt::from_hex_unchecked("0xbabe0000").compact(),
+            &[Token::Bytes(&[0xba, 0xbe, 0, 0])],
+        );
+    }
+
+    #[test]
+    fn backward_compatible_deserialization() {
+        static TWO_SERIALIZED_USING_PREVIOUS_IMPLEMENTATION: [u8; 33] = [
+            32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 2,
+        ];
+
+        let options = bincode::DefaultOptions::new();
+        let deserialized = options
+            .deserialize(&TWO_SERIALIZED_USING_PREVIOUS_IMPLEMENTATION)
+            .unwrap();
+        assert_eq!(Felt::TWO, deserialized);
+    }
+
+    proptest! {
+        #[test]
+        fn compact_round_trip(ref x in any::<Felt>()) {
+            let serialized = bincode::serialize(&x).unwrap();
+            let deserialized: Felt = bincode::deserialize(&serialized).unwrap();
+            prop_assert_eq!(x, &deserialized);
+        }
     }
 }