refactor(common/class_definition): use bytes::Bytes instead of Vec<u8> for serialized definitions

crates/class-hash/src/lib.rs

@@ -109,8 +109,8 @@ pub fn compute_class_hash(
                     // It is safe to reinterpret the serialized definition as a Sierra definition
                     // since the parsing step succeeded and confirmed it is a
                     // Sierra definition.
-                    SerializedClassDefinition::Sierra(SerializedSierraDefinition::from_bytes(
-                        serialized_definition.into_bytes(),
+                    SerializedClassDefinition::Sierra(SerializedSierraDefinition::from(
+                        serialized_definition.into_inner(),
                     )),
                 )
             }),
@@ -122,8 +122,8 @@ pub fn compute_class_hash(
                     hash,
                     // It is safe to reinterpret the serialized definition as a Cairo definition
                     // since the parsing step succeeded and confirmed it is a Cairo definition.
-                    SerializedClassDefinition::Cairo(SerializedCairoDefinition::from_bytes(
-                        serialized_definition.into_bytes(),
+                    SerializedClassDefinition::Cairo(SerializedCairoDefinition::from(
+                        serialized_definition.into_inner(),
                     )),
                 )
             }),
@@ -166,11 +166,11 @@ pub fn compute_cairo_hinted_class_hash(
 fn parse_contract_definition(
     serialized_definition: &SerializedOpaqueClassDefinition,
 ) -> serde_json::Result<json::ContractDefinition<'_>> {
-    serde_json::from_slice::<json::SierraContractDefinition<'_>>(serialized_definition.as_bytes())
+    serde_json::from_slice::<json::SierraContractDefinition<'_>>(serialized_definition.as_slice())
         .map(json::ContractDefinition::Sierra)
         .or_else(|_| {
             serde_json::from_slice::<json::CairoContractDefinition<'_>>(
-                serialized_definition.as_bytes(),
+                serialized_definition.as_slice(),
             )
             .map(json::ContractDefinition::Cairo)
         })

crates/common/Cargo.toml

@@ -23,6 +23,7 @@ full-serde = []
 anyhow = { workspace = true }
 base64 = { workspace = true }
 bitvec = { workspace = true }
+bytes = { workspace = true }
 fake = { workspace = true, features = ["derive"] }
 metrics = { workspace = true }
 num-bigint = { workspace = true }
@@ -34,7 +35,10 @@ pathfinder-tagged-debug-derive = { version = "0.1.0", path = "../tagged-debug-de
 primitive-types = { workspace = true, features = ["serde"] }
 rand = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
-serde_json = { workspace = true, features = ["arbitrary_precision", "raw_value"] }
+serde_json = { workspace = true, features = [
+    "arbitrary_precision",
+    "raw_value",
+] }
 serde_with = { workspace = true }
 sha3 = { workspace = true }
 thiserror = { workspace = true }

crates/common/src/casm_class.rs

@@ -94,6 +94,6 @@ impl CasmContractClass {
     pub fn from_serialized_def(
         definition: &crate::class_definition::SerializedCasmDefinition,
     ) -> Result<Self, serde_json::Error> {
-        serde_json::from_slice(definition.as_bytes())
+        serde_json::from_slice(definition.as_slice())
     }
 }

crates/common/src/class_definition.rs

@@ -1,6 +1,7 @@
 use std::borrow::Cow;
 use std::fmt;
 
+use bytes::Bytes;
 use fake::{Dummy, Fake, Faker};
 use pathfinder_crypto::Felt;
 use rand::Rng;
@@ -12,19 +13,19 @@ use crate::{ByteCodeOffset, EntryPoint};
 
 pub const CLASS_DEFINITION_MAX_ALLOWED_SIZE: u64 = 4 * 1024 * 1024;
 
-#[derive(Clone, Debug, Default, PartialEq, Eq, Hash, Dummy)]
-pub struct SerializedSierraDefinition(Vec<u8>);
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+pub struct SerializedSierraDefinition(Bytes);
 
-#[derive(Clone, Debug, Default, PartialEq, Eq, Hash, Dummy)]
-pub struct SerializedCasmDefinition(Vec<u8>);
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+pub struct SerializedCasmDefinition(Bytes);
 
-#[derive(Clone, Debug, Default, PartialEq, Eq, Hash, Dummy)]
-pub struct SerializedCairoDefinition(Vec<u8>);
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+pub struct SerializedCairoDefinition(Bytes);
 
 /// Carries the definition of a serialized contract class, either Sierra or
 /// Cairo. The caller does not care which class definition it is.
-#[derive(Clone, Debug, Default, PartialEq, Eq, Hash, Dummy)]
-pub struct SerializedOpaqueClassDefinition(Vec<u8>);
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+pub struct SerializedOpaqueClassDefinition(Bytes);
 
 /// Carries the definition of a serialized contract class, either Sierra or
 /// Cairo.
@@ -214,87 +215,127 @@ pub struct SelectorAndFunctionIndex {
 }
 
 impl SerializedSierraDefinition {
-    pub fn from_bytes(bytes: Vec<u8>) -> Self {
-        Self(bytes)
+    pub fn from_vec(bytes: Vec<u8>) -> Self {
+        Self(Bytes::from_owner(bytes))
     }
 
     pub fn from_slice(bytes: &[u8]) -> Self {
-        Self(bytes.to_vec())
+        Self(Bytes::copy_from_slice(bytes))
     }
 
-    pub fn into_bytes(self) -> Vec<u8> {
-        self.0
+    pub fn into_vec(self) -> Vec<u8> {
+        self.0.into()
     }
 
-    pub fn as_bytes(&self) -> &[u8] {
+    pub fn as_slice(&self) -> &[u8] {
         &self.0
     }
 }
 
-impl SerializedCasmDefinition {
-    pub fn from_bytes(bytes: Vec<u8>) -> Self {
+impl From<Bytes> for SerializedSierraDefinition {
+    fn from(bytes: Bytes) -> Self {
         Self(bytes)
     }
+}
+
+impl SerializedCasmDefinition {
+    pub fn from_vec(bytes: Vec<u8>) -> Self {
+        Self(Bytes::from_owner(bytes))
+    }
 
     pub fn from_slice(bytes: &[u8]) -> Self {
-        Self(bytes.to_vec())
+        Self(Bytes::copy_from_slice(bytes))
     }
 
-    pub fn into_bytes(self) -> Vec<u8> {
-        self.0
+    pub fn into_vec(self) -> Vec<u8> {
+        self.0.into()
     }
 
-    pub fn as_bytes(&self) -> &[u8] {
+    pub fn as_slice(&self) -> &[u8] {
         &self.0
     }
 }
 
 impl SerializedCairoDefinition {
-    pub fn from_bytes(bytes: Vec<u8>) -> Self {
-        Self(bytes)
+    pub fn from_vec(bytes: Vec<u8>) -> Self {
+        Self(Bytes::from_owner(bytes))
     }
 
     pub fn from_slice(bytes: &[u8]) -> Self {
-        Self(bytes.to_vec())
+        Self(Bytes::copy_from_slice(bytes))
     }
 
-    pub fn into_bytes(self) -> Vec<u8> {
-        self.0
+    pub fn into_vec(self) -> Vec<u8> {
+        self.0.into()
     }
 
-    pub fn as_bytes(&self) -> &[u8] {
+    pub fn as_slice(&self) -> &[u8] {
         &self.0
     }
 }
 
-impl SerializedOpaqueClassDefinition {
-    pub fn from_bytes(bytes: Vec<u8>) -> Self {
+impl From<Bytes> for SerializedCairoDefinition {
+    fn from(bytes: Bytes) -> Self {
         Self(bytes)
     }
+}
+
+impl SerializedOpaqueClassDefinition {
+    pub fn from_vec(bytes: Vec<u8>) -> Self {
+        Self(Bytes::from_owner(bytes))
+    }
 
     pub fn from_slice(bytes: &[u8]) -> Self {
-        Self(bytes.to_vec())
+        Self(Bytes::copy_from_slice(bytes))
     }
 
-    pub fn into_bytes(self) -> Vec<u8> {
-        self.0
+    pub fn into_vec(self) -> Vec<u8> {
+        self.0.into()
     }
 
-    pub fn as_bytes(&self) -> &[u8] {
+    pub fn as_slice(&self) -> &[u8] {
         &self.0
     }
+
+    pub fn into_inner(self) -> Bytes {
+        self.0
+    }
 }
 
 /// We can use `From` because this is always safe.
 impl From<SerializedSierraDefinition> for SerializedOpaqueClassDefinition {
     fn from(d: SerializedSierraDefinition) -> Self {
-        Self::from_bytes(d.into_bytes())
+        Self::from_vec(d.into_vec())
     }
 }
 
 /// We can use `From` because this is always safe.
 impl From<SerializedCairoDefinition> for SerializedOpaqueClassDefinition {
     fn from(d: SerializedCairoDefinition) -> Self {
-        Self::from_bytes(d.into_bytes())
+        Self::from_vec(d.into_vec())
+    }
+}
+
+impl<T> Dummy<T> for SerializedSierraDefinition {
+    fn dummy_with_rng<R: rand::prelude::Rng + ?Sized>(_: &T, rng: &mut R) -> Self {
+        Self(Bytes::from(Faker.fake_with_rng::<Vec<u8>, R>(rng)))
+    }
+}
+
+impl<T> Dummy<T> for SerializedCasmDefinition {
+    fn dummy_with_rng<R: rand::prelude::Rng + ?Sized>(_: &T, rng: &mut R) -> Self {
+        Self(Bytes::from(Faker.fake_with_rng::<Vec<u8>, R>(rng)))
+    }
+}
+
+impl<T> Dummy<T> for SerializedCairoDefinition {
+    fn dummy_with_rng<R: rand::prelude::Rng + ?Sized>(_: &T, rng: &mut R) -> Self {
+        Self(Bytes::from(Faker.fake_with_rng::<Vec<u8>, R>(rng)))
+    }
+}
+
+impl<T> Dummy<T> for SerializedOpaqueClassDefinition {
+    fn dummy_with_rng<R: rand::prelude::Rng + ?Sized>(_: &T, rng: &mut R) -> Self {
+        Self(Bytes::from(Faker.fake_with_rng::<Vec<u8>, R>(rng)))
     }
 }

crates/compiler/src/lib.rs

@@ -127,7 +127,7 @@ pub fn compile_sierra_to_casm(
     {
         let mut ch_stdin = child.stdin.take().context("opening child stdin")?;
         ch_stdin
-            .write_all(sierra_definition.as_bytes())
+            .write_all(sierra_definition.as_slice())
             .context("writing Sierra definition to child stdin")?;
         ch_stdin.flush().context("flushing child stdin")?;
     }
@@ -145,7 +145,7 @@ pub fn compile_sierra_to_casm(
         );
     }
 
-    Ok(SerializedCasmDefinition::from_bytes(output.stdout))
+    Ok(SerializedCasmDefinition::from_vec(output.stdout))
 }
 
 /// Compile a Sierra class definition into CASM using an isolated child process.
@@ -165,7 +165,7 @@ pub fn compile_sierra_to_casm_deser(
         .context("serializing Sierra definition")
         .map(|sierra_definition| {
             compile_sierra_to_casm(
-                &class_definition::SerializedSierraDefinition::from_bytes(sierra_definition),
+                &class_definition::SerializedSierraDefinition::from_vec(sierra_definition),
                 resource_limits,
                 blockifier_libfuncs,
             )
@@ -317,7 +317,7 @@ pub fn compile_sierra_to_casm_impl(
     // representation used by the feeder gateway for Sierra classes, so we have to
     // convert the JSON to something that can be parsed into the expected input
     // format for the compiler.
-    serde_json::from_slice::<class_definition::Sierra<'_>>(sierra_definition.as_bytes())
+    serde_json::from_slice::<class_definition::Sierra<'_>>(sierra_definition.as_slice())
         .context("Parsing Sierra class")
         .map(|sierra_class| compile_sierra_to_casm_deser_impl(sierra_class, blockifier_libfuncs))?
         .context("Compiling Sierra to CASM")
@@ -385,7 +385,7 @@ fn parse_sierra_version(program: &[Felt]) -> anyhow::Result<SierraVersion> {
 ///
 /// Uses the _latest_ compiler for the parsing and starknet_api for the hashing.
 pub fn casm_class_hash_v2(casm_definition: &SerializedCasmDefinition) -> anyhow::Result<CasmHash> {
-    v2::casm_class_hash_v2(casm_definition.as_bytes())
+    v2::casm_class_hash_v2(casm_definition.as_slice())
 }
 
 mod v1_0_0_alpha6 {
@@ -431,7 +431,7 @@ mod v1_0_0_alpha6 {
 
         let casm_class = CasmContractClass::from_contract_class(sierra_class, true)
             .context("Compiling to CASM")?;
-        Ok(super::SerializedCasmDefinition::from_bytes(
+        Ok(super::SerializedCasmDefinition::from_vec(
             serde_json::to_vec(&casm_class)?,
         ))
     }
@@ -480,7 +480,7 @@ mod v1_0_0_rc0 {
 
         let casm_class = CasmContractClass::from_contract_class(sierra_class, true)
             .context("Compiling to CASM")?;
-        Ok(super::SerializedCasmDefinition::from_bytes(
+        Ok(super::SerializedCasmDefinition::from_vec(
             serde_json::to_vec(&casm_class)?,
         ))
     }
@@ -529,7 +529,7 @@ mod v1_1_1 {
 
         let casm_class = CasmContractClass::from_contract_class(sierra_class, true)
             .context("Compiling to CASM")?;
-        Ok(super::SerializedCasmDefinition::from_bytes(
+        Ok(super::SerializedCasmDefinition::from_vec(
             serde_json::to_vec(&casm_class)?,
         ))
     }
@@ -582,7 +582,7 @@ mod v2 {
             usize::MAX,
         )
         .context("Compiling to CASM")?;
-        Ok(super::SerializedCasmDefinition::from_bytes(
+        Ok(super::SerializedCasmDefinition::from_vec(
             serde_json::to_vec(&casm_class)?,
         ))
     }

crates/executor/src/class.rs

@@ -8,7 +8,7 @@ pub fn parse_deprecated_class_definition(
     definition: SerializedOpaqueClassDefinition,
 ) -> anyhow::Result<starknet_api::contract_class::ContractClass> {
     let class: starknet_api::deprecated_contract_class::ContractClass =
-        serde_json::from_slice(definition.as_bytes())?;
+        serde_json::from_slice(definition.as_slice())?;
 
     Ok(starknet_api::contract_class::ContractClass::V0(class))
 }
@@ -17,7 +17,7 @@ pub fn parse_casm_definition(
     casm_definition: SerializedCasmDefinition,
     sierra_version: starknet_api::contract_class::SierraVersion,
 ) -> anyhow::Result<starknet_api::contract_class::ContractClass> {
-    let class: CasmContractClass = serde_json::from_slice(casm_definition.as_bytes())?;
+    let class: CasmContractClass = serde_json::from_slice(casm_definition.as_slice())?;
 
     Ok(starknet_api::contract_class::ContractClass::V1((
         class,

crates/executor/src/state_reader.rs

@@ -166,7 +166,7 @@ impl<S: StorageAdapter> PathfinderStateReader<S> {
             None => {
                 // No CASM definition means this is a legacy Cairo 0 class.
                 let class_definition =
-                    std::str::from_utf8(class_definition.as_bytes()).map_err(|error| {
+                    std::str::from_utf8(class_definition.as_slice()).map_err(|error| {
                         StateError::StateReadError(format!(
                             "Class definition is not valid UTF-8: {error}"
                         ))
@@ -189,7 +189,7 @@ impl<S: StorageAdapter> PathfinderStateReader<S> {
     ) -> Result<SierraVersion, StateError> {
         use cairo_vm::types::errors::program_errors::ProgramError;
 
-        let sierra_class: Sierra<'_> = serde_json::from_slice(class_definition.as_bytes())
+        let sierra_class: Sierra<'_> = serde_json::from_slice(class_definition.as_slice())
             .map_err(|error| StateError::ProgramError(ProgramError::Parse(error)))?;
         SierraVersion::extract_from_program(&sierra_class.sierra_program).map_err(Into::into)
     }
@@ -199,7 +199,7 @@ fn sierra_class_as_casm(
     sierra_version: SierraVersion,
     casm_definition: SerializedCasmDefinition,
 ) -> Result<RunnableCompiledClass, StateError> {
-    let casm_definition = std::str::from_utf8(casm_definition.as_bytes()).map_err(|error| {
+    let casm_definition = std::str::from_utf8(casm_definition.as_slice()).map_err(|error| {
         StateError::StateReadError(format!("CASM definition is not valid UTF-8: {error}"))
     })?;
     let casm_class = blockifier::execution::contract_class::CompiledClassV1::try_from_json_string(