chore(blockifier_test_utils): delete tag-and-toolchain related code

Author: dorimedini-starkware

crates/blockifier_test_utils/src/cairo_compile.rs

@@ -1,19 +1,16 @@
+use std::fs;
 use std::io::Write;
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 use std::process::{Command, Output, Stdio};
 use std::sync::LazyLock;
-use std::{env, fs};
 
 use apollo_infra_utils::cairo_compiler_version::cairo1_compiler_version;
-use apollo_infra_utils::compile_time_cargo_manifest_dir;
 use apollo_infra_utils::path::{project_path, resolve_project_relative_path};
 use tempfile::NamedTempFile;
 use tracing::info;
 
 static CAIRO0_PIP_REQUIREMENTS_FILE: LazyLock<PathBuf> =
     LazyLock::new(|| resolve_project_relative_path("scripts/requirements.txt").unwrap());
-const CAIRO1_REPO_RELATIVE_PATH_OVERRIDE_ENV_VAR: &str = "CAIRO1_REPO_RELATIVE_PATH";
-const DEFAULT_CAIRO1_REPO_RELATIVE_PATH: &str = "../../../cairo";
 
 pub enum CompilationArtifacts {
     Cairo0 { casm: Vec<u8> },
@@ -24,19 +21,6 @@ pub fn cairo1_compiler_tag() -> String {
     format!("v{}", cairo1_compiler_version())
 }
 
-/// Returns the path to the local Cairo1 compiler repository.
-/// Returns <sequencer_repo_root>/<RELATIVE_PATH_TO_CAIRO_REPO>, where the relative path can be
-/// overridden by the environment variable (otherwise, the default is used).
-fn local_cairo1_compiler_repo_path() -> PathBuf {
-    // Location of blockifier's Cargo.toml.
-    let manifest_dir = compile_time_cargo_manifest_dir!();
-
-    Path::new(&manifest_dir).join(
-        env::var(CAIRO1_REPO_RELATIVE_PATH_OVERRIDE_ENV_VAR)
-            .unwrap_or_else(|_| DEFAULT_CAIRO1_REPO_RELATIVE_PATH.into()),
-    )
-}
-
 /// Path to local compiler package directory, of the specified version.
 fn cairo1_package_dir(version: &String) -> PathBuf {
     project_path().unwrap().join(format!("target/bin/cairo_package__{version}"))
@@ -127,13 +111,7 @@ pub fn cairo0_compile(
 }
 
 /// Compiles a Cairo1 program using the compiler version set in the Cargo.toml.
-pub fn cairo1_compile(
-    path: String,
-    git_tag_override: Option<String>,
-    _cargo_nightly_arg: Option<String>,
-) -> CompilationArtifacts {
-    let (tag, _cairo_repo_path) = get_tag_and_repo_file_path(git_tag_override);
-    let version = tag.strip_prefix("v").unwrap().to_string();
+pub fn cairo1_compile(path: String, version: String) -> CompilationArtifacts {
     assert!(cairo1_package_exists(&version));
 
     let sierra_output = starknet_compile(path, &version);
@@ -202,17 +180,3 @@ fn verify_cairo0_compiler_deps() {
         *CAIRO0_PIP_REQUIREMENTS_FILE
     );
 }
-
-fn get_tag_and_repo_file_path(git_tag_override: Option<String>) -> (String, PathBuf) {
-    let tag = git_tag_override.unwrap_or(cairo1_compiler_tag());
-    let cairo_repo_path = local_cairo1_compiler_repo_path();
-    // Check if the path is a directory.
-    assert!(
-        cairo_repo_path.is_dir(),
-        "Cannot verify Cairo1 contracts, Cairo repo not found at {0}.\nPlease run:\n\
-        git clone https://github.com/starkware-libs/cairo {0}\nThen rerun the test.",
-        cairo_repo_path.to_string_lossy(),
-    );
-
-    (tag, cairo_repo_path)
-}

crates/blockifier_test_utils/src/contracts.rs

@@ -2,6 +2,7 @@ use std::collections::HashMap;
 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;
@@ -77,16 +78,12 @@ const ERC20_CAIRO1_CONTRACT_SOURCE_PATH: &str = "./resources/ERC20/ERC20_Cairo1/
 const ERC20_SIERRA_CONTRACT_PATH: &str = "./resources/ERC20/ERC20_Cairo1/erc20.sierra.json";
 const ERC20_CAIRO1_CONTRACT_PATH: &str = "./resources/ERC20/ERC20_Cairo1/erc20.casm.json";
 
-// The following contracts are compiled with a fixed version of the compiler. This compiler version
-// no longer compiles with stable rust, so the toolchain is also fixed.
-const LEGACY_CONTRACT_COMPILER_TAG: &str = "v2.1.0";
-const LEGACY_CONTRACT_RUST_TOOLCHAIN: &str = "2023-07-05";
+// The following contracts are compiled with a fixed version of the compiler.
+const LEGACY_CONTRACT_COMPILER_VERSION: &str = "2.1.0";
+const CAIRO_STEPS_TEST_CONTRACT_COMPILER_VERSION: &str = "2.7.0";
 
-const CAIRO_STEPS_TEST_CONTRACT_COMPILER_TAG: &str = "v2.7.0";
-const CAIRO_STEPS_TEST_CONTRACT_RUST_TOOLCHAIN: &str = "2024-04-29";
-
-pub type TagAndToolchain = (Option<String>, Option<String>);
-pub type TagToContractsMapping = HashMap<TagAndToolchain, Vec<FeatureContract>>;
+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.
@@ -197,20 +194,20 @@ impl FeatureContract {
         }
     }
 
-    /// Some contracts are designed to test behavior of code compiled with a
-    /// specific (old) compiler tag. To run the (old) compiler, older rust
-    /// version is required.
-    pub fn fixed_tag_and_rust_toolchain(&self) -> TagAndToolchain {
+    /// Some Cairo1 contracts are designed to test behavior of code compiled with a specific (old)
+    /// compiler version. Returns the compiler version used to compile the contract.
+    /// Panics if called on a Cairo0 contract.
+    pub fn fixed_version(&self) -> CairoVersionString {
         match self {
-            Self::LegacyTestContract => (
-                Some(LEGACY_CONTRACT_COMPILER_TAG.into()),
-                Some(LEGACY_CONTRACT_RUST_TOOLCHAIN.into()),
-            ),
-            Self::CairoStepsTestContract => (
-                Some(CAIRO_STEPS_TEST_CONTRACT_COMPILER_TAG.into()),
-                Some(CAIRO_STEPS_TEST_CONTRACT_RUST_TOOLCHAIN.into()),
-            ),
-            _ => (None, None),
+            Self::LegacyTestContract => LEGACY_CONTRACT_COMPILER_VERSION.into(),
+            Self::CairoStepsTestContract => CAIRO_STEPS_TEST_CONTRACT_COMPILER_VERSION.into(),
+            contract => {
+                assert!(
+                    !contract.cairo_version().is_cairo0(),
+                    "fixed_version() should only be called for Cairo1 contracts."
+                );
+                cairo1_compiler_version()
+            }
         }
     }
 
@@ -343,10 +340,7 @@ impl FeatureContract {
                 };
                 cairo0_compile(self.get_source_path(), extra_arg, false)
             }
-            CairoVersion::Cairo1(_) => {
-                let (tag_override, cargo_nightly_arg) = self.fixed_tag_and_rust_toolchain();
-                cairo1_compile(self.get_source_path(), tag_override, cargo_nightly_arg)
-            }
+            CairoVersion::Cairo1(_) => cairo1_compile(self.get_source_path(), self.fixed_version()),
         }
     }
 
@@ -410,10 +404,10 @@ impl FeatureContract {
         Self::all_contracts().filter(|contract| !matches!(contract, Self::ERC20(_)))
     }
 
-    pub fn cairo1_feature_contracts_by_tag() -> TagToContractsMapping {
+    pub fn cairo1_feature_contracts_by_version() -> VersionToContractsMapping {
         Self::all_feature_contracts()
             .filter(|contract| contract.cairo_version() != CairoVersion::Cairo0)
-            .map(|contract| (contract.fixed_tag_and_rust_toolchain(), contract))
+            .map(|contract| (contract.fixed_version(), contract))
             .into_group_map()
     }
 }

crates/blockifier_test_utils/tests/feature_contracts_compatibility_test.rs

@@ -1,10 +1,6 @@
 use std::fs;
 
-use blockifier_test_utils::cairo_compile::{
-    cairo1_compiler_tag,
-    verify_cairo1_package,
-    CompilationArtifacts,
-};
+use blockifier_test_utils::cairo_compile::{verify_cairo1_package, CompilationArtifacts};
 use blockifier_test_utils::cairo_versions::{CairoVersion, RunnableCairo1};
 use blockifier_test_utils::contracts::{
     FeatureContract,
@@ -86,15 +82,9 @@ async fn verify_feature_contracts_compatibility(fix: bool, cairo_version: CairoV
             }
         }
         CairoVersion::Cairo1(RunnableCairo1::Casm) => {
-            for (tag_and_tool_chain, feature_contracts) in
-                FeatureContract::cairo1_feature_contracts_by_tag()
+            for (version, feature_contracts) in
+                FeatureContract::cairo1_feature_contracts_by_version()
             {
-                let version = tag_and_tool_chain
-                    .0
-                    .unwrap_or(cairo1_compiler_tag())
-                    .strip_prefix("v")
-                    .unwrap()
-                    .to_string();
                 verify_cairo1_package(&version).await;
 
                 let mut task_set = tokio::task::JoinSet::new();