Code reorg (#133)

Author: tdelabro

crates/starknet-types-core/Cargo.toml

@@ -32,6 +32,7 @@ zeroize = { version = "1.8.1", default-features = false, optional = true }
 [features]
 default = ["std", "serde", "curve", "num-traits"]
 std = [
+  "alloc",
   "lambdaworks-math/std",
   "num-traits/std",
   "num-bigint/std",
@@ -52,7 +53,7 @@ papyrus-serialization = ["std"]
 zeroize = ["dep:zeroize"]
 
 [dev-dependencies]
-proptest = "1.5"
+proptest = { version = "1.5", default-features = false, features = ["alloc", "proptest-macro"] } 
 regex = "1.11"
 serde_test = "1"
 criterion = "0.5"

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

@@ -0,0 +1,94 @@
+use core::fmt;
+
+use super::alloc;
+use super::Felt;
+
+impl Felt {
+    /// Helper to represent the felt value as a zero-padded hexadecimal string.
+    ///
+    /// Equivalent to calling `format!("{self:#x}")`.
+    pub fn to_hex_string(&self) -> alloc::string::String {
+        alloc::format!("{self:#x}")
+    }
+
+    /// Helper to represent the felt value as a zero-padded hexadecimal string.
+    ///
+    /// The resulting string will consist of:
+    /// 1. A`0x` prefix,
+    /// 2. an amount of padding zeros so that the resulting string length is fixed (This amount may be 0),
+    /// 3. the felt value represented in hexadecimal
+    ///
+    /// The resulting string is guaranted to be 66 chars long, which is enough to represent `Felt::MAX`:
+    /// 2 chars for the `0x` prefix and 64 chars for the padded hexadecimal felt value.
+    pub fn to_fixed_hex_string(&self) -> alloc::string::String {
+        let hex_str = alloc::format!("{self:#x}");
+        if hex_str.len() < 66 {
+            alloc::format!("0x{:0>64}", hex_str.strip_prefix("0x").unwrap())
+        } else {
+            hex_str
+        }
+    }
+}
+
+/// Represents [Felt] in lowercase hexadecimal format.
+impl fmt::LowerHex for Felt {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let hex = alloc::string::ToString::to_string(&self.0);
+        let hex = hex.strip_prefix("0x").unwrap();
+
+        let width = if f.sign_aware_zero_pad() {
+            f.width().unwrap().min(64)
+        } else {
+            1
+        };
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+
+        if hex.len() < width {
+            for _ in 0..(width - hex.len()) {
+                write!(f, "0")?;
+            }
+        }
+        write!(f, "{}", hex)
+    }
+}
+
+/// Represents [Felt] in uppercase hexadecimal format.
+impl fmt::UpperHex for Felt {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let hex = alloc::string::ToString::to_string(&self.0);
+        let hex = hex.strip_prefix("0x").unwrap().to_uppercase();
+
+        let width = if f.sign_aware_zero_pad() {
+            f.width().unwrap().min(64)
+        } else {
+            1
+        };
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+
+        if hex.len() < width {
+            for _ in 0..(width - hex.len()) {
+                write!(f, "0")?;
+            }
+        }
+        write!(f, "{}", hex)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use alloc::format;
+    use proptest::prelude::*;
+
+    proptest! {
+        #[test]
+        fn to_hex_string_is_same_as_format(ref x in any::<Felt>()) {
+            let y = alloc::format!("{x:#x}");
+            prop_assert_eq!(y, x.to_hex_string());
+        }
+    }
+}

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

@@ -0,0 +1,21 @@
+use crate::felt::Felt;
+use arbitrary::{self, Arbitrary, Unstructured};
+use lambdaworks_math::field::element::FieldElement;
+use lambdaworks_math::unsigned_integer::element::UnsignedInteger;
+
+impl Arbitrary<'_> for Felt {
+    // Creates an arbitrary `Felt` from unstructured input for fuzzing.
+    // It uses the default implementation to create the internal limbs and then
+    // uses the usual constructors from `lambdaworks-math`.
+    fn arbitrary(u: &mut Unstructured) -> arbitrary::Result<Self> {
+        let limbs = <[u64; 4]>::arbitrary(u)?;
+        let uint = UnsignedInteger::from_limbs(limbs);
+        let felt = FieldElement::new(uint);
+        Ok(Felt(felt))
+    }
+
+    #[inline]
+    fn size_hint(depth: usize) -> (usize, Option<usize>) {
+        <[u64; 4]>::size_hint(depth)
+    }
+}