feat: implement try from felt for signed integers

crates/dojo-types/src/lib.rs

@@ -7,6 +7,7 @@ use starknet::core::types::Felt;
 pub mod event;
 pub mod packing;
 pub mod primitive;
+pub mod primitive_conversion;
 pub mod schema;
 pub mod storage;
 pub mod system;

crates/dojo-types/src/primitive.rs

@@ -7,6 +7,8 @@
 use strum::IntoEnumIterator;
 use strum_macros::{AsRefStr, Display, EnumIter, EnumString};
 
+use super::primitive_conversion::try_from_felt;
+
 #[derive(
     AsRefStr,
     Display,
@@ -148,11 +150,11 @@
             Primitive::Felt252(_) => 8,
             Primitive::ClassHash(_) => 9,
             Primitive::ContractAddress(_) => 10,
             Primitive::I8(_) => 11,
             Primitive::I16(_) => 12,
             Primitive::I32(_) => 13,
             Primitive::I64(_) => 14,
             Primitive::I128(_) => 15,
         }
     }
 
@@ -230,41 +232,36 @@
         match self {
             Primitive::I8(ref mut value) => {
                 let felt = felts.remove(0);
-                *value = Some(felt.to_i8().ok_or_else(|| PrimitiveError::ValueOutOfRange {
-                    r#type: type_name::<i8>(),
-                    value: felt,
+                *value = Some(try_from_felt::<i8>(felt).map_err(|_| {
+                    PrimitiveError::ValueOutOfRange { r#type: type_name::<i8>(), value: felt }
                 })?);
             }
 
             Primitive::I16(ref mut value) => {
                 let felt = felts.remove(0);
-                *value = Some(felt.to_i16().ok_or_else(|| PrimitiveError::ValueOutOfRange {
-                    r#type: type_name::<i16>(),
-                    value: felt,
+                *value = Some(try_from_felt::<i16>(felt).map_err(|_| {
+                    PrimitiveError::ValueOutOfRange { r#type: type_name::<i16>(), value: felt }
                 })?);
             }
 
             Primitive::I32(ref mut value) => {
                 let felt = felts.remove(0);
-                *value = Some(felt.to_i32().ok_or_else(|| PrimitiveError::ValueOutOfRange {
-                    r#type: type_name::<i32>(),
-                    value: felt,
+                *value = Some(try_from_felt::<i32>(felt).map_err(|_| {
+                    PrimitiveError::ValueOutOfRange { r#type: type_name::<i32>(), value: felt }
                 })?);
             }
 
             Primitive::I64(ref mut value) => {
                 let felt = felts.remove(0);
-                *value = Some(felt.to_i64().ok_or_else(|| PrimitiveError::ValueOutOfRange {
-                    r#type: type_name::<i64>(),
-                    value: felt,
+                *value = Some(try_from_felt::<i64>(felt).map_err(|_| {
+                    PrimitiveError::ValueOutOfRange { r#type: type_name::<i64>(), value: felt }
                 })?);
             }
 
             Primitive::I128(ref mut value) => {
                 let felt = felts.remove(0);
-                *value = Some(felt.to_i128().ok_or_else(|| PrimitiveError::ValueOutOfRange {
-                    r#type: type_name::<i128>(),
-                    value: felt,
+                *value = Some(try_from_felt::<i128>(felt).map_err(|_| {
+                    PrimitiveError::ValueOutOfRange { r#type: type_name::<i128>(), value: felt }
                 })?);
             }
 
@@ -322,12 +319,12 @@
                 *value = Some(U256::from_be_bytes(bytes));
             }
 
             Primitive::USize(ref mut value) => {
                 let felt = felts.remove(0);
                 *value = Some(felt.to_u32().ok_or_else(|| PrimitiveError::ValueOutOfRange {
                     r#type: type_name::<u32>(),
                     value: felt,
                 })?);
             }
 
             Primitive::Bool(ref mut value) => {
@@ -397,9 +394,9 @@
                     Ok(vec![value0, value1])
                 })
                 .unwrap_or(Err(PrimitiveError::MissingFieldElement)),
             Primitive::USize(value) => value
                 .map(|v| Ok(vec![Felt::from(v)]))
                 .unwrap_or(Err(PrimitiveError::MissingFieldElement)),
             Primitive::Bool(value) => value
                 .map(|v| Ok(vec![if v { Felt::ONE } else { Felt::ZERO }]))
                 .unwrap_or(Err(PrimitiveError::MissingFieldElement)),
@@ -425,6 +422,8 @@
 
     use super::Primitive;
 
+    use super::try_from_felt;
+
     #[test]
     fn test_u256() {
         let primitive = Primitive::U256(Some(U256::from_be_hex(
@@ -498,4 +497,32 @@
         primitive.set_contract_address(Some(Felt::from(1u128))).unwrap();
         assert_eq!(primitive.as_contract_address(), Some(Felt::from(1u128)));
     }
+
+    #[test]
+    fn test_try_from_felt() {
+        let i_8: i8 = -64;
+        let felt = Felt::from(i_8);
+        let signed_integer = try_from_felt::<i8>(felt).unwrap();
+        assert_eq!(i_8, signed_integer);
+
+        let i_16: i16 = -14293;
+        let felt = Felt::from(i_16);
+        let signed_integer = try_from_felt::<i16>(felt).unwrap();
+        assert_eq!(i_16, signed_integer);
+
+        let i_32: i32 = -194875;
+        let felt = Felt::from(i_32);
+        let signed_integer = try_from_felt::<i32>(felt).unwrap();
+        assert_eq!(i_32, signed_integer);
+
+        let i_64: i64 = -3147483648;
+        let felt = Felt::from(i_64);
+        let signed_integer = try_from_felt::<i64>(felt).unwrap();
+        assert_eq!(i_64, signed_integer);
+
+        let i_128: i128 = -170141183460469231731687303715884105728;
+        let felt = Felt::from(i_128);
+        let signed_integer = try_from_felt::<i128>(felt).unwrap();
+        assert_eq!(i_128, signed_integer);
+    }
 }

crates/dojo-types/src/primitive_conversion.rs

@@ -0,0 +1,58 @@
+use core::convert::TryInto;
+use starknet::core::types::Felt;
+
+#[derive(Debug, Copy, Clone)]
+pub struct PrimitiveFromFeltError;
+
+impl core::fmt::Display for PrimitiveFromFeltError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "Failed to convert `Felt` into primitive type")
+    }
+}
+
+const MINUS_TWO_BYTES_REPR: [u8; 32] = [
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 16, 0, 0, 0, 0, 0, 0, 8,
+];
+
+pub trait FromFelt: Sized {
+    fn try_from_felt(value: Felt) -> Result<Self, PrimitiveFromFeltError>;
+}
+
+macro_rules! impl_from_felt {
+    ($into:ty) => {
+        impl FromFelt for $into {
+            fn try_from_felt(value: Felt) -> Result<Self, PrimitiveFromFeltError> {
+                let size_of_type = core::mem::size_of::<$into>();
+                let bytes_le = value.to_bytes_le();
+
+                if bytes_le[size_of_type..].iter().all(|&v| v == 0)
+                    && bytes_le[size_of_type - 1] <= 0b01111111
+                {
+                    Ok(<$into>::from_le_bytes(bytes_le[..size_of_type].try_into().unwrap()))
+                } else if bytes_le[size_of_type..] == MINUS_TWO_BYTES_REPR[size_of_type..]
+                    && bytes_le[size_of_type - 1] >= 0b10000000
+                {
+                    let offsetted_value =
+                        <$into>::from_le_bytes(bytes_le[..size_of_type].try_into().unwrap());
+
+                    offsetted_value.checked_sub(1).ok_or(PrimitiveFromFeltError)
+                } else if bytes_le[24..] == [17, 0, 0, 0, 0, 0, 0, 8] {
+                    return Ok(-1);
+                } else {
+                    Err(PrimitiveFromFeltError)
+                }
+            }
+        }
+    };
+}
+
+impl_from_felt!(i8);
+impl_from_felt!(i16);
+impl_from_felt!(i32);
+impl_from_felt!(i64);
+impl_from_felt!(i128);
+
+pub fn try_from_felt<T: FromFelt>(value: Felt) -> Result<T, PrimitiveFromFeltError> {
+    T::try_from_felt(value)
+}

crates/torii/types-test/src/contracts.cairo

@@ -61,11 +61,11 @@ mod records {
                         Record {
                             record_id,
                             depth: Depth::Zero,
-                            type_i8: record_idx.into(),
-                            type_i16: record_idx.into(),
-                            type_i32: record_idx.into(),
-                            type_i64: record_idx.into(),
-                            type_i128: record_idx.into(),
+                            type_i8: type_felt.try_into().unwrap(),
+                            type_i16: type_felt.try_into().unwrap(),
+                            type_i32: type_felt.try_into().unwrap(),
+                            type_i64: type_felt.try_into().unwrap(),
+                            type_i128: type_felt.try_into().unwrap(),
                             type_u8: record_idx.into(),
                             type_u16: record_idx.into(),
                             type_u32: record_idx.into(),

examples/spawn-and-move/src/actions.cairo

@@ -85,7 +85,8 @@ mod actions {
             let player = get_caller_address();
 
             let items = array![
-                PlayerItem { item_id: 1, quantity: 100 }, PlayerItem { item_id: 2, quantity: 50 }
+                PlayerItem { item_id: 1, quantity: 100, score: 10 },
+                PlayerItem { item_id: 2, quantity: 50, score: -32 }
             ];
 
             let config = PlayerConfig { player, name, items, favorite_item: Option::Some(1), };

examples/spawn-and-move/src/models.cairo

@@ -74,6 +74,7 @@ struct Position {
 struct PlayerItem {
     item_id: u32,
     quantity: u32,
+    score: i32,
 }
 
 #[derive(Drop, Serde)]