Refactor RawFeltVec

crates/cheatnet/src/runtime_extensions/call_to_blockifier_runtime_extension/execution/execution_info.rs

@@ -3,10 +3,8 @@ use cairo_vm::{
     types::relocatable::{MaybeRelocatable, Relocatable},
     vm::vm_core::VirtualMachine,
 };
-use conversions::{
-    IntoConv,
-    serde::serialize::{SerializeToFeltVec, raw::RawFeltVec},
-};
+use conversions::serde::SerializedValue;
+use conversions::{IntoConv, serde::serialize::SerializeToFeltVec};
 use starknet_types_core::felt::Felt;
 
 fn get_cheated_block_info_ptr(
@@ -90,8 +88,10 @@ fn get_cheated_tx_info_ptr(
         new_tx_info[7] = MaybeRelocatable::Int(nonce);
     }
     if let Some(resource_bounds) = resource_bounds {
-        let (resource_bounds_start_ptr, resource_bounds_end_ptr) =
-            add_vec_memory_segment(&RawFeltVec::new(resource_bounds).serialize_to_vec(), vm);
+        let (resource_bounds_start_ptr, resource_bounds_end_ptr) = add_vec_memory_segment(
+            &SerializedValue::new(resource_bounds).serialize_to_vec(),
+            vm,
+        );
         new_tx_info[8] = resource_bounds_start_ptr.into();
         new_tx_info[9] = resource_bounds_end_ptr.into();
     }

crates/conversions/src/serde.rs

@@ -1,2 +1,5 @@
 pub mod deserialize;
 pub mod serialize;
+pub mod serialized_value;
+
+pub use serialized_value::SerializedValue;

crates/conversions/src/serde/deserialize/deserialize_impl.rs

@@ -53,6 +53,19 @@ where
     }
 }
 
+impl<T: CairoDeserialize, E: CairoDeserialize> CairoDeserialize for Result<T, E> {
+    fn deserialize(reader: &mut BufferReader<'_>) -> BufferReadResult<Self> {
+        let variant: Felt = reader.read()?;
+        let variant: usize = variant.to_usize().ok_or(BufferReadError::ParseFailed)?;
+
+        match variant {
+            0 => Ok(Ok(reader.read()?)),
+            1 => Ok(Err(reader.read()?)),
+            _ => Err(BufferReadError::ParseFailed),
+        }
+    }
+}
+
 impl CairoDeserialize for bool {
     fn deserialize(reader: &mut BufferReader<'_>) -> BufferReadResult<Self> {
         let num: usize = reader.read()?;

crates/conversions/src/serde/serialize.rs

@@ -2,7 +2,6 @@ use starknet_types_core::felt::Felt;
 
 pub use cairo_serde_macros::CairoSerialize;
 
-pub mod raw;
 mod serialize_impl;
 
 pub struct BufferWriter {

crates/conversions/src/serde/serialized_value.rs

@@ -0,0 +1,42 @@
+use conversions::serde::deserialize::{BufferReadResult, BufferReader, CairoDeserialize};
+use conversions::serde::serialize::{BufferWriter, CairoSerialize};
+use starknet_types_core::felt::Felt;
+
+/// Represents an already serialized Vec of values.
+///
+/// Use this to omit adding extra felt for the length of the vector during serialization.
+#[derive(Debug)]
+pub struct SerializedValue<T>(pub Vec<T>)
+where
+    T: CairoSerialize;
+
+impl<T> SerializedValue<T>
+where
+    T: CairoSerialize,
+{
+    #[must_use]
+    pub fn new(vec: Vec<T>) -> Self {
+        Self(vec)
+    }
+}
+
+impl<T> CairoSerialize for SerializedValue<T>
+where
+    T: CairoSerialize,
+{
+    fn serialize(&self, output: &mut BufferWriter) {
+        for e in &self.0 {
+            e.serialize(output);
+        }
+    }
+}
+
+impl CairoDeserialize for SerializedValue<Felt> {
+    fn deserialize(reader: &mut BufferReader<'_>) -> BufferReadResult<Self> {
+        let mut result: Vec<Felt> = Vec::new();
+        while let Ok(r) = reader.read_felt() {
+            result.push(r);
+        }
+        Ok(Self::new(result))
+    }
+}

crates/runtime/src/lib.rs

@@ -18,9 +18,9 @@ use cairo_vm::vm::errors::vm_errors::VirtualMachineError;
 use cairo_vm::vm::runners::cairo_runner::{ResourceTracker, RunResources};
 use cairo_vm::vm::vm_core::VirtualMachine;
 use conversions::byte_array::ByteArray;
+use conversions::serde::SerializedValue;
 use conversions::serde::deserialize::BufferReadError;
 use conversions::serde::deserialize::BufferReader;
-use conversions::serde::serialize::raw::RawFeltVec;
 use conversions::serde::serialize::{CairoSerialize, SerializeToFeltVec};
 use indoc::indoc;
 use shared::vm::VirtualMachineExt;
@@ -294,7 +294,7 @@ impl<Extension: ExtensionLogic> ExtendedRuntime<Extension> {
                 return res;
             }
             // it is serialized again to add `Result` discriminator
-            Ok(CheatcodeHandlingResult::Handled(res)) => Ok(RawFeltVec::new(res)),
+            Ok(CheatcodeHandlingResult::Handled(res)) => Ok(SerializedValue::new(res)),
             Err(err) => Err(ByteArray::from(err.to_string().as_str())),
         }
         .serialize_to_vec();