implement num_traits and some some primitive conversions

Author: FrancoGiachetta

crates/starknet-types-core/src/qm31/mod.rs

@@ -1,5 +1,5 @@
+mod num_traits_impl;
 mod primitive_conversions;
-mod qm31_num_traits_impl;
 
 use core::fmt;
 
@@ -39,7 +39,7 @@ impl fmt::Display for QM31Error {
 }
 
 /// Definition of a Quad M31 in its reduced form. The internal representation
-/// is composed by the coordinates of the QM31, following a little endian ordering.
+/// is composed by the coordinates of the QM31, following a big endian ordering.
 #[repr(transparent)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct QM31([u64; 4]);
@@ -68,26 +68,26 @@ impl QM31 {
     /// Packs the [QM31] coordinates into a Felt.
     fn pack_into_felt(&self) -> Felt {
         let mut felt_bytes = [0; 32];
-        let bytes = self.to_le_bytes();
+        let bytes = self.to_bytes_le();
 
         felt_bytes[0..18].copy_from_slice(&bytes);
 
         Felt::from_bytes_le(&felt_bytes)
     }
 
     fn to_biguint(&self) -> BigUint {
-        let bytes = self.to_le_bytes();
-
-        BigUint::from_bytes_le(&bytes)
+        dbg!(self);
+        let bytes = self.to_bytes_be();
+        BigUint::from_bytes_be(&bytes)
     }
 
     fn to_bigint(&self) -> BigInt {
         self.to_biguint().into()
     }
 
     /// Convert `self`'s inner into an array of bytes,
-    /// following the little endian ordering.
-    pub fn to_le_bytes(&self) -> [u8; 18] {
+    /// following the big endian ordering.
+    pub fn to_bytes_le(&self) -> [u8; 18] {
         let coordinates = self.inner();
 
         let mut result_bytes = [0u8; 18];
@@ -99,6 +99,22 @@ impl QM31 {
         result_bytes
     }
 
+    /// Convert `self`'s inner into an array of bytes,
+    /// following the big endian ordering.
+    pub fn to_bytes_be(&self) -> [u8; 18] {
+        let coordinates = self.inner();
+
+        let mut result_bytes = [0u8; 18];
+        let bytes_part1 =
+            (((coordinates[0] as u128) << 36) + (coordinates[1] as u128)).to_be_bytes();
+        let bytes_part2 =
+            (((coordinates[2] as u128) << 36) + (coordinates[3] as u128)).to_be_bytes();
+        result_bytes[0..9].copy_from_slice(&bytes_part1[7..16]);
+        result_bytes[9..18].copy_from_slice(&bytes_part2[7..16]);
+
+        result_bytes
+    }
+
     /// Computes the addition of two [QM31] elements in reduced form.
     pub fn add(&self, rhs: &QM31) -> QM31 {
         let coordinates1 = self.inner();

crates/starknet-types-core/src/qm31/qm31_num_traits_impl.rs renamed to crates/starknet-types-core/src/qm31/num_traits_impl.rs

@@ -120,7 +120,7 @@ mod tests {
         assert_eq!(qm31.to_u64().unwrap(), 10u64);
         let qm31 = QM31::from(u64::MAX);
         assert_eq!(qm31.to_u64().unwrap(), u64::MAX);
-        
+
         let qm31 = QM31::from(0u128);
         assert_eq!(qm31.to_u128().unwrap(), 0u128);
         let qm31 = QM31::from(10u128);

crates/starknet-types-core/src/qm31/primitive_conversions.rs

@@ -55,10 +55,13 @@ macro_rules! try_from_qm31_to_unsigned {
             type Error = PrimitiveFromQM31Error;
 
             fn try_from(value: QM31) -> Result<Self, Self::Error> {
-                let bytes = value.to_le_bytes();
+                let bytes = value.to_bytes_be();
 
-                let (bytes_return, bytes_check) = bytes.split_at(core::mem::size_of::<$into>());
+                let (bytes_check, bytes_return) =
+                    bytes.split_at(18 - core::mem::size_of::<$into>());
 
+                // A QM31 follows a big-endian ordering. Since it can be represented with 18 bytes (144 bits), we
+                // need to check that the first size_of::<QM31> - size_of::<$into> bytes are zero.
                 if bytes_check.iter().all(|&b| b == 0) {
                     Ok(<$into>::from_be_bytes(bytes_return.try_into().unwrap()))
                 } else {