chore(blockifier_test_utils): delete dead code

crates/blockifier_test_utils/Cargo.toml

@@ -12,7 +12,6 @@ cairo_native = []
 [dependencies]
 apollo_infra_utils = { workspace = true, features = ["testing"] }
 cairo-lang-starknet-classes.workspace = true
-itertools.workspace = true
 pretty_assertions.workspace = true
 rstest.workspace = true
 serde_json = { workspace = true, features = ["arbitrary_precision"] }

crates/blockifier_test_utils/src/contracts.rs

@@ -1,11 +1,10 @@
-use std::collections::HashMap;
+use std::collections::HashSet;
 use std::fs;
 use std::path::PathBuf;
 
 use apollo_infra_utils::cairo_compiler_version::cairo1_compiler_version;
 use apollo_infra_utils::compile_time_cargo_manifest_dir;
 use cairo_lang_starknet_classes::contract_class::ContractClass as CairoLangContractClass;
-use itertools::Itertools;
 use starknet_api::contract_class::SierraVersion;
 use starknet_api::core::{ClassHash, CompiledClassHash, ContractAddress};
 use starknet_api::state::SierraContractClass;
@@ -83,7 +82,6 @@ const LEGACY_CONTRACT_COMPILER_VERSION: &str = "2.1.0";
 const CAIRO_STEPS_TEST_CONTRACT_COMPILER_VERSION: &str = "2.7.0";
 
 pub type CairoVersionString = String;
-pub type VersionToContractsMapping = HashMap<CairoVersionString, Vec<FeatureContract>>;
 
 /// Enum representing all feature contracts.
 /// The contracts that are implemented in both Cairo versions include a version field.
@@ -404,11 +402,19 @@ impl FeatureContract {
         Self::all_contracts().filter(|contract| !matches!(contract, Self::ERC20(_)))
     }
 
-    pub fn cairo1_feature_contracts_by_version() -> VersionToContractsMapping {
+    pub fn all_cairo1_casm_feature_contracts() -> impl Iterator<Item = Self> {
+        Self::all_feature_contracts().filter(|contract| {
+            matches!(contract.cairo_version(), CairoVersion::Cairo1(RunnableCairo1::Casm))
+        })
+    }
+
+    pub fn all_cairo1_casm_compiler_versions() -> HashSet<CairoVersionString> {
         Self::all_feature_contracts()
-            .filter(|contract| contract.cairo_version() != CairoVersion::Cairo0)
-            .map(|contract| (contract.fixed_version(), contract))
-            .into_group_map()
+            .filter(|contract| {
+                contract.cairo_version() == CairoVersion::Cairo1(RunnableCairo1::Casm)
+            })
+            .map(|contract| contract.fixed_version())
+            .collect()
     }
 }
 

crates/blockifier_test_utils/tests/feature_contracts_compatibility_test.rs

@@ -72,8 +72,8 @@ pub struct Cairo1FeatureContractMetadata {
 // 2. for each `X.cairo` file in `TEST_CONTRACTS` there exists an `X_compiled.json` file in
 // `COMPILED_CONTRACTS_SUBDIR` which equals `starknet-compile-deprecated X.cairo --no_debug_info`.
 async fn verify_feature_contracts_compatibility(fix: bool, cairo_version: CairoVersion) {
-    // TODO(Dori, 1/10/2024): Parallelize this test.
     match cairo_version {
+        // TODO(Dori, 1/10/2024): Parallelize Cairo0 recompilation.
         CairoVersion::Cairo0 => {
             for contract in FeatureContract::all_feature_contracts()
                 .filter(|contract| contract.cairo_version() == cairo_version)
@@ -84,30 +84,20 @@ async fn verify_feature_contracts_compatibility(fix: bool, cairo_version: CairoV
         CairoVersion::Cairo1(RunnableCairo1::Casm) => {
             // Prepare cairo packages.
             let mut download_task_set = tokio::task::JoinSet::new();
-            for (version, _feature_contracts) in
-                FeatureContract::cairo1_feature_contracts_by_version()
-            {
+            for version in FeatureContract::all_cairo1_casm_compiler_versions() {
                 download_task_set.spawn(async move { verify_cairo1_package(&version).await });
             }
             info!(
                 "Verifying Cairo1 packages for versions {:?}.",
-                FeatureContract::cairo1_feature_contracts_by_version().keys()
+                FeatureContract::all_cairo1_casm_compiler_versions()
             );
             download_task_set.join_all().await;
             info!("Cairo1 packages verified.");
             // Verify feature contracts.
             let mut task_set = tokio::task::JoinSet::new();
-            for (_version, feature_contracts) in
-                FeatureContract::cairo1_feature_contracts_by_version()
-            {
-                for contract in feature_contracts
-                    .into_iter()
-                    .filter(|contract| contract.cairo_version() == cairo_version)
-                {
-                    info!("Spawning task for {contract:?}.");
-                    task_set
-                        .spawn(verify_feature_contracts_compatibility_logic_async(contract, fix));
-                }
+            for contract in FeatureContract::all_cairo1_casm_feature_contracts() {
+                info!("Spawning task for {contract:?}.");
+                task_set.spawn(verify_feature_contracts_compatibility_logic_async(contract, fix));
             }
             info!("Done spawning tasks for contract compilation. Awaiting them...");
             task_set.join_all().await;