clean dependencies

crates/client/block_import/Cargo.toml

@@ -10,7 +10,6 @@ license.workspace = true
 
 [dependencies]
 bitvec.workspace = true
-futures.workspace = true
 log.workspace = true
 rayon.workspace = true
 thiserror.workspace = true
@@ -24,10 +23,8 @@ dp-convert = { workspace = true }
 dp-receipt = { workspace = true }
 dp-state-update = { workspace = true }
 dp-transactions = { workspace = true }
-dp-utils = { workspace = true }
 
 bonsai-trie = { workspace = true }
 starknet-core = { workspace = true }
-starknet-providers = { workspace = true }
 starknet-types-core = { workspace = true }
 starknet_api = { workspace = true }

crates/client/block_import/src/pre_validate.rs

@@ -14,6 +14,7 @@ use starknet_api::core::ChainId;
 use starknet_core::types::Felt;
 use starknet_types_core::hash::{Pedersen, Poseidon, StarkHash};
 use std::mem;
+use std::sync::Arc;
 
 /// This function wraps the [`pre_validate_inner`] step, which runs on the rayon pool, in a tokio-friendly future.
 pub async fn pre_validate(
@@ -159,15 +160,15 @@ fn class_conversion(_validation: &Validation, class: DeclaredClass) -> Result<Co
             }
             Ok(ConvertedClass::Sierra(SierraConvertedClass {
                 class_hash: sierra.class_hash,
-                info: SierraClassInfo { contract_class: sierra.contract_class, compiled_class_hash },
-                compiled: compiled_class,
+                info: SierraClassInfo { contract_class: Arc::new(sierra.contract_class), compiled_class_hash },
+                compiled: Arc::new(compiled_class),
             }))
         }
         DeclaredClass::Legacy(legacy) => {
             // TODO: verify that the class hash is correct
             Ok(ConvertedClass::Legacy(LegacyConvertedClass {
                 class_hash: legacy.class_hash,
-                info: LegacyClassInfo { contract_class: legacy.contract_class },
+                info: LegacyClassInfo { contract_class: Arc::new(legacy.contract_class) },
             }))
         }
     }

crates/client/eth/Cargo.toml

@@ -16,7 +16,6 @@ targets = ["x86_64-unknown-linux-gnu"]
 # Deoxys
 dc-db = { workspace = true }
 dc-metrics = { workspace = true }
-dp-block = { workspace = true }
 dp-chain-config = { workspace = true }
 dp-convert = { workspace = true }
 dp-transactions = { workspace = true }

crates/client/mempool/Cargo.toml

@@ -43,6 +43,5 @@ starknet_api.workspace = true
 # Other
 anyhow.workspace = true
 log.workspace = true
-rayon.workspace = true
 thiserror.workspace = true
 tokio.workspace = true

crates/client/sync/Cargo.toml

@@ -29,12 +29,10 @@ dp-chain-config = { workspace = true }
 dp-class = { workspace = true }
 dp-convert = { workspace = true }
 dp-receipt = { workspace = true }
-dp-state-update = { workspace = true }
 dp-transactions = { workspace = true }
 dp-utils = { workspace = true }
 
 # Starknet
-bonsai-trie = { workspace = true }
 starknet-core = { workspace = true }
 starknet-providers = { workspace = true }
 starknet-types-core = { workspace = true }
@@ -43,13 +41,9 @@ starknet_api = { workspace = true }
 
 # Other
 anyhow = { workspace = true }
-bitvec = { workspace = true }
 futures = { workspace = true, default-features = true }
 log = { workspace = true }
 num-traits = { workspace = true }
-rand = { workspace = true }
-rayon = { workspace = true }
-reqwest = { workspace = true }
 rodio = { version = "0.17", optional = true }
 serde_json = { workspace = true }
 thiserror.workspace = true

crates/node/Cargo.toml

@@ -49,7 +49,6 @@ hyper.workspace = true
 ip_network.workspace = true
 jsonrpsee.workspace = true
 log = { workspace = true }
-primitive-types = { workspace = true }
 rand = { workspace = true }
 rayon.workspace = true
 reqwest = { workspace = true }

crates/primitives/block/Cargo.toml

@@ -15,19 +15,15 @@ targets = ["x86_64-unknown-linux-gnu"]
 
 # Deoxys
 dp-chain-config = { workspace = true }
-dp-convert = { workspace = true }
 dp-receipt = { workspace = true }
 dp-transactions = { workspace = true }
 
 # Starknet
 blockifier = { workspace = true }
 starknet-core = { workspace = true }
 starknet-types-core = { workspace = true }
-starknet_api = { workspace = true }
 
 # Other
-lazy_static = { workspace = true }
 primitive-types.workspace = true
 serde = { workspace = true, features = ["derive"] }
-serde_json = { workspace = true }
 thiserror = { workspace = true }

crates/primitives/chain_config/Cargo.toml

@@ -11,7 +11,6 @@ license.workspace = true
 
 # Starknet
 blockifier = { workspace = true }
-starknet-core = { workspace = true }
 starknet-types-core = { workspace = true }
 starknet_api = { workspace = true }
 

crates/primitives/class/Cargo.toml

@@ -27,12 +27,10 @@ casm-utils-v1_0_0-alpha6 = { package = "cairo-lang-utils", git = "https://github
 casm-utils-v1_0_0-rc0 = { package = "cairo-lang-utils", git = "https://github.com/starkware-libs/cairo", tag = "v1.0.0-rc0" }
 casm-utils-v1_1_1 = { package = "cairo-lang-utils", version = "=1.1.1" }
 casm-utils-v2 = { package = "cairo-lang-utils", version = "=2.7.0-rc.2" }
-sha3 = { workspace = true }
 starknet-core = { workspace = true }
 starknet-types-core = { workspace = true }
 
 # Other
-anyhow = { workspace = true }
 flate2 = { workspace = true }
 num-bigint = { workspace = true }
 serde = { workspace = true }

crates/primitives/class/src/into_starknet_core.rs

@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use crate::{
     CompressedLegacyContractClass, ContractClass, EntryPointsByType, FlattenedSierraClass, FunctionStateMutability,
     LegacyContractAbiEntry, LegacyContractEntryPoint, LegacyEntryPointsByType, LegacyEventAbiEntry, LegacyEventAbiType,
@@ -9,10 +11,10 @@ impl From<starknet_core::types::ContractClass> for ContractClass {
     fn from(contract_class: starknet_core::types::ContractClass) -> Self {
         match contract_class {
             starknet_core::types::ContractClass::Sierra(flattened_sierra_class) => {
-                ContractClass::Sierra(flattened_sierra_class.into())
+                ContractClass::Sierra(Arc::new(flattened_sierra_class.into()))
             }
             starknet_core::types::ContractClass::Legacy(compressed_legacy_contract_class) => {
-                ContractClass::Legacy(compressed_legacy_contract_class.into())
+                ContractClass::Legacy(Arc::new(compressed_legacy_contract_class.into()))
             }
         }
     }
@@ -22,10 +24,10 @@ impl From<ContractClass> for starknet_core::types::ContractClass {
     fn from(contract_class: ContractClass) -> Self {
         match contract_class {
             ContractClass::Sierra(flattened_sierra_class) => {
-                starknet_core::types::ContractClass::Sierra(flattened_sierra_class.into())
+                starknet_core::types::ContractClass::Sierra((*flattened_sierra_class).clone().into())
             }
             ContractClass::Legacy(compressed_legacy_contract_class) => {
-                starknet_core::types::ContractClass::Legacy(compressed_legacy_contract_class.into())
+                starknet_core::types::ContractClass::Legacy((*compressed_legacy_contract_class).clone().into())
             }
         }
     }

crates/primitives/class/src/lib.rs

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::{collections::HashMap, sync::Arc};
 
 use starknet_types_core::felt::Felt;
 
@@ -7,7 +7,7 @@ pub mod class_update;
 pub mod compile;
 mod into_starknet_core;
 
-#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub enum ConvertedClass {
     Legacy(LegacyConvertedClass),
     Sierra(SierraConvertedClass),
@@ -21,7 +21,6 @@ impl ConvertedClass {
         }
     }
 
-    // TODO: remove clone
     pub fn info(&self) -> ClassInfo {
         match self {
             ConvertedClass::Legacy(legacy) => ClassInfo::Legacy(legacy.info.clone()),
@@ -40,7 +39,7 @@ pub struct LegacyConvertedClass {
 pub struct SierraConvertedClass {
     pub class_hash: Felt,
     pub info: SierraClassInfo,
-    pub compiled: CompiledSierra,
+    pub compiled: Arc<CompiledSierra>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
@@ -64,38 +63,38 @@ impl From<SierraClassInfo> for ClassInfo {
 impl ClassInfo {
     pub fn contract_class(&self) -> ContractClass {
         match self {
-            ClassInfo::Sierra(SierraClassInfo { contract_class, .. }) => contract_class.clone().into(),
-            ClassInfo::Legacy(LegacyClassInfo { contract_class }) => contract_class.clone().into(),
+            ClassInfo::Sierra(sierra) => ContractClass::Sierra(Arc::clone(&sierra.contract_class)),
+            ClassInfo::Legacy(legacy) => ContractClass::Legacy(Arc::clone(&legacy.contract_class)),
         }
     }
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub struct LegacyClassInfo {
-    pub contract_class: CompressedLegacyContractClass,
+    pub contract_class: Arc<CompressedLegacyContractClass>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub struct SierraClassInfo {
-    pub contract_class: FlattenedSierraClass,
+    pub contract_class: Arc<FlattenedSierraClass>,
     pub compiled_class_hash: Felt,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub enum ContractClass {
-    Sierra(FlattenedSierraClass),
-    Legacy(CompressedLegacyContractClass),
+    Sierra(Arc<FlattenedSierraClass>),
+    Legacy(Arc<CompressedLegacyContractClass>),
 }
 
 impl From<FlattenedSierraClass> for ContractClass {
     fn from(flattened_sierra_class: FlattenedSierraClass) -> Self {
-        ContractClass::Sierra(flattened_sierra_class)
+        ContractClass::Sierra(Arc::new(flattened_sierra_class))
     }
 }
 
 impl From<CompressedLegacyContractClass> for ContractClass {
     fn from(compressed_legacy_contract_class: CompressedLegacyContractClass) -> Self {
-        ContractClass::Legacy(compressed_legacy_contract_class)
+        ContractClass::Legacy(Arc::new(compressed_legacy_contract_class))
     }
 }
 

crates/primitives/convert/Cargo.toml

@@ -12,7 +12,6 @@ homepage.workspace = true
 
 # Starknet
 starknet-core = { workspace = true }
-starknet-providers = { workspace = true }
 starknet-types-core = { workspace = true }
 starknet_api = { workspace = true }
 

crates/primitives/state_update/src/lib.rs

@@ -54,6 +54,16 @@ impl StateDiff {
         result
     }
 
+    pub fn sort(&mut self) {
+        self.storage_diffs.iter_mut().for_each(|storage_diff| storage_diff.sort());
+        self.storage_diffs.sort_by_key(|storage_diff| storage_diff.address);
+        self.deprecated_declared_classes.sort();
+        self.declared_classes.sort_by_key(|declared_class| declared_class.class_hash);
+        self.deployed_contracts.sort_by_key(|deployed_contract| deployed_contract.address);
+        self.replaced_classes.sort_by_key(|replaced_class| replaced_class.contract_address);
+        self.nonces.sort_by_key(|nonce| nonce.contract_address);
+    }
+
     pub fn compute_hash(&self) -> Felt {
         let updated_contracts_sorted = {
             let mut updated_contracts = self
@@ -142,7 +152,12 @@ impl ContractStorageDiffItem {
     fn len(&self) -> usize {
         self.storage_entries.len()
     }
+
+    pub fn sort(&mut self) {
+        self.storage_entries.sort_by_key(|storage_entry| storage_entry.key);
+    }
 }
+
 #[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub struct StorageEntry {
     pub key: Felt,