Implemented kosher data transformer

crates/cheatnet/src/runtime_extensions/forge_runtime_extension/mod.rs

@@ -37,8 +37,9 @@ use cairo_vm::vm::{
 use cairo_vm::Felt252;
 use conversions::byte_array::ByteArray;
 use conversions::felt252::TryInferFormat;
-use conversions::serde::deserialize::{BufferReader, CairoDeserialize};
+use conversions::serde::deserialize::BufferReader;
 use conversions::serde::serialize::CairoSerialize;
+use conversions::u256::CairoU256;
 use runtime::{
     CheatcodeHandlingResult, EnhancedHintError, ExtendedRuntime, ExtensionLogic,
     SyscallHandlingResult,
@@ -491,30 +492,6 @@ impl<'a> ExtensionLogic for ForgeExtension<'a> {
     }
 }
 
-#[derive(CairoDeserialize, CairoSerialize)]
-struct CairoU256 {
-    low: u128,
-    high: u128,
-}
-
-impl CairoU256 {
-    fn from_bytes(bytes: &[u8]) -> Self {
-        Self {
-            low: u128::from_be_bytes(bytes[16..32].try_into().unwrap()),
-            high: u128::from_be_bytes(bytes[0..16].try_into().unwrap()),
-        }
-    }
-
-    fn to_be_bytes(&self) -> [u8; 32] {
-        let mut result = [0; 32];
-
-        result[16..].copy_from_slice(&self.low.to_be_bytes());
-        result[..16].copy_from_slice(&self.high.to_be_bytes());
-
-        result
-    }
-}
-
 #[derive(CairoSerialize)]
 enum SignError {
     InvalidSecretKey,

crates/conversions/Cargo.toml

@@ -24,6 +24,7 @@ serde.workspace = true
 num-traits.workspace = true
 itertools.workspace = true
 cairo-serde-macros = { path = "cairo-serde-macros" }
+num-bigint.workspace = true
 
 [dev-dependencies]
 ctor.workspace = true

crates/conversions/src/lib.rs

@@ -10,6 +10,8 @@ pub mod nonce;
 pub mod primitive;
 pub mod serde;
 pub mod string;
+pub mod u256;
+pub mod u512;
 
 pub trait FromConv<T>: Sized {
     fn from_(value: T) -> Self;

crates/conversions/src/serde/serialize/serialize_impl.rs

@@ -229,6 +229,12 @@ impl_serialize_for_num_type!(u64);
 impl_serialize_for_num_type!(u128);
 impl_serialize_for_num_type!(usize);
 
+impl_serialize_for_num_type!(i8);
+impl_serialize_for_num_type!(i16);
+impl_serialize_for_num_type!(i32);
+impl_serialize_for_num_type!(i64);
+impl_serialize_for_num_type!(i128);
+
 impl_serialize_for_tuple!();
 impl_serialize_for_tuple!(A);
 impl_serialize_for_tuple!(A, B);

crates/conversions/src/u256.rs

@@ -0,0 +1,56 @@
+use crate as conversions; // Must be imported because of derive macros
+use cairo_serde_macros::{CairoDeserialize, CairoSerialize};
+use num_bigint::{BigUint, ParseBigIntError};
+use std::str::FromStr;
+
+#[derive(CairoDeserialize, CairoSerialize, Debug)]
+pub struct CairoU256 {
+    low: u128,
+    high: u128,
+}
+
+impl CairoU256 {
+    #[must_use]
+    pub fn from_bytes(bytes: &[u8]) -> Self {
+        Self {
+            low: u128::from_be_bytes(bytes[16..32].try_into().unwrap()),
+            high: u128::from_be_bytes(bytes[0..16].try_into().unwrap()),
+        }
+    }
+
+    #[must_use]
+    pub fn to_be_bytes(&self) -> [u8; 32] {
+        let mut result = [0; 32];
+
+        result[16..].copy_from_slice(&self.low.to_be_bytes());
+        result[..16].copy_from_slice(&self.high.to_be_bytes());
+
+        result
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
+pub enum ParseCairoU256Error {
+    #[error(transparent)]
+    InvalidString(#[from] ParseBigIntError),
+    #[error("Number is too large to fit in 32 bytes")]
+    Overflow,
+}
+
+impl FromStr for CairoU256 {
+    type Err = ParseCairoU256Error;
+
+    fn from_str(input: &str) -> Result<Self, Self::Err> {
+        let bytes = input.parse::<BigUint>()?.to_bytes_be();
+
+        if bytes.len() > 32 {
+            return Err(ParseCairoU256Error::Overflow);
+        }
+
+        let mut result = [0u8; 32];
+        let start = 32 - bytes.len();
+        result[start..].copy_from_slice(&bytes);
+
+        Ok(CairoU256::from_bytes(&result))
+    }
+}

crates/conversions/src/u512.rs

@@ -0,0 +1,62 @@
+use crate as conversions; // Must be imported because of derive macros
+use cairo_serde_macros::{CairoDeserialize, CairoSerialize};
+use num_bigint::{BigUint, ParseBigIntError};
+use std::str::FromStr;
+
+#[derive(CairoDeserialize, CairoSerialize, Debug)]
+pub struct CairoU512 {
+    limb_0: u128,
+    limb_1: u128,
+    limb_2: u128,
+    limb_3: u128,
+}
+
+impl CairoU512 {
+    #[must_use]
+    pub fn from_bytes(bytes: &[u8]) -> Self {
+        Self {
+            limb_0: u128::from_be_bytes(bytes[48..64].try_into().unwrap()),
+            limb_1: u128::from_be_bytes(bytes[32..48].try_into().unwrap()),
+            limb_2: u128::from_be_bytes(bytes[16..32].try_into().unwrap()),
+            limb_3: u128::from_be_bytes(bytes[00..16].try_into().unwrap()),
+        }
+    }
+
+    #[must_use]
+    pub fn to_be_bytes(&self) -> [u8; 64] {
+        let mut result = [0; 64];
+
+        result[48..64].copy_from_slice(&self.limb_0.to_be_bytes());
+        result[32..48].copy_from_slice(&self.limb_1.to_be_bytes());
+        result[16..32].copy_from_slice(&self.limb_2.to_be_bytes());
+        result[00..16].copy_from_slice(&self.limb_3.to_be_bytes());
+
+        result
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
+pub enum ParseCairoU512Error {
+    #[error(transparent)]
+    InvalidString(#[from] ParseBigIntError),
+    #[error("Number is too large to fit in 64 bytes")]
+    Overflow,
+}
+
+impl FromStr for CairoU512 {
+    type Err = ParseCairoU512Error;
+
+    fn from_str(input: &str) -> Result<Self, Self::Err> {
+        let bytes = input.parse::<BigUint>()?.to_bytes_be();
+
+        if bytes.len() > 64 {
+            return Err(ParseCairoU512Error::Overflow);
+        }
+
+        let mut result = [0u8; 64];
+        let start = 64 - bytes.len();
+        result[start..].copy_from_slice(&bytes);
+
+        Ok(CairoU512::from_bytes(&result))
+    }
+}

crates/sncast/Cargo.toml

@@ -35,8 +35,13 @@ cairo-lang-casm.workspace = true
 cairo-lang-sierra-to-casm.workspace = true
 cairo-lang-utils.workspace = true
 cairo-lang-sierra.workspace = true
+cairo-lang-parser.workspace = true
+cairo-lang-syntax.workspace = true
+cairo-lang-diagnostics.workspace = true
+cairo-lang-filesystem.workspace = true
 itertools.workspace = true
 num-traits.workspace = true
+num-bigint.workspace = true
 starknet-types-core.workspace = true
 cairo-vm.workspace = true
 blockifier.workspace = true