feat(apollo_infra_utils): better cairo0 compiler checks

Author: dorimedini-starkware

Cargo.lock

@@ -19,12 +19,15 @@ colored = { workspace = true, optional = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json.workspace = true
 socket2 = { workspace = true, optional = true }
+thiserror.workspace = true
 tokio = { workspace = true, features = ["process", "rt", "time"] }
 toml = { workspace = true, optional = true }
 tracing.workspace = true
 
 [dev-dependencies]
+assert-json-diff.workspace = true
 cached.workspace = true
+colored.workspace = true
 nix.workspace = true
 pretty_assertions.workspace = true
 rstest.workspace = true

crates/apollo_infra_utils/Cargo.toml

@@ -1,38 +1,67 @@
-use std::fs;
 use std::path::PathBuf;
 use std::process::Command;
 use std::sync::LazyLock;
 
 use crate::path::resolve_project_relative_path;
 
+#[cfg(test)]
+#[path = "cairo0_compiler_test.rs"]
+pub mod test;
+
+pub const STARKNET_COMPILE_DEPRECATED: &str = "starknet-compile-deprecated";
+pub const CAIRO0_COMPILE: &str = "cairo-compile";
+pub const EXPECTED_CAIRO0_VERSION: &str = "0.13.5";
+
 /// The local python requirements used to determine the cairo0 compiler version.
-static PIP_REQUIREMENTS_FILE: LazyLock<PathBuf> =
+pub(crate) static PIP_REQUIREMENTS_FILE: LazyLock<PathBuf> =
     LazyLock::new(|| resolve_project_relative_path("scripts/requirements.txt").unwrap());
 
+#[derive(thiserror::Error, Debug)]
+pub enum Cairo0CompilerVersionError {
+    #[error("{compiler} version is not correct: required {required}, got {existing}.")]
+    IncorrectVersion { compiler: String, existing: String, required: String },
+    #[error("{0} not found.")]
+    NotFound(String),
+}
+
+pub fn cairo0_compilers_correct_version() -> Result<(), Cairo0CompilerVersionError> {
+    for compiler in [CAIRO0_COMPILE, STARKNET_COMPILE_DEPRECATED] {
+        let version = match Command::new(compiler).arg("--version").output() {
+            Ok(output) => String::from_utf8_lossy(&output.stdout).to_string(),
+            Err(error) => {
+                return Err(Cairo0CompilerVersionError::NotFound(format!(
+                    "Failed to get {compiler} version: {error}."
+                )));
+            }
+        };
+        if !version.trim().ends_with(EXPECTED_CAIRO0_VERSION) {
+            return Err(Cairo0CompilerVersionError::IncorrectVersion {
+                compiler: compiler.to_string(),
+                existing: version,
+                required: EXPECTED_CAIRO0_VERSION.to_string(),
+            });
+        }
+    }
+
+    Ok(())
+}
+
 /// Verifies that the required Cairo0 compiler is available; panics if unavailable.
 pub fn verify_cairo0_compiler_deps() {
-    // Python compiler. Verify correct version.
-    let cairo_lang_version_output =
-        Command::new("sh").arg("-c").arg("pip freeze | grep cairo-lang").output().unwrap().stdout;
-    let cairo_lang_version_untrimmed = String::from_utf8(cairo_lang_version_output).unwrap();
-    let cairo_lang_version = cairo_lang_version_untrimmed.trim();
-    let requirements_contents = fs::read_to_string(&*PIP_REQUIREMENTS_FILE).unwrap();
-    let expected_cairo_lang_version = requirements_contents
-        .lines()
-        .find(|line| line.starts_with("cairo-lang"))
-        .unwrap_or_else(|| panic!("Could not find cairo-lang in {:?}.", *PIP_REQUIREMENTS_FILE))
-        .trim();
-
-    assert!(
-        expected_cairo_lang_version.ends_with(cairo_lang_version),
-        "cairo-lang version {expected_cairo_lang_version} not found ({}). Run the following \
-         commands (enter a python venv and install dependencies) and retry:\npython -m venv \
-         sequencer_venv\n. sequencer_venv/bin/activate\npip install -r {:?}",
-        if cairo_lang_version.is_empty() {
-            String::from("no installed cairo-lang found")
-        } else {
-            format!("installed version: {cairo_lang_version}")
-        },
-        *PIP_REQUIREMENTS_FILE
+    let specific_error = match cairo0_compilers_correct_version() {
+        Ok(_) => {
+            return;
+        }
+        Err(Cairo0CompilerVersionError::NotFound(_)) => "no installed cairo-lang found".to_string(),
+        Err(Cairo0CompilerVersionError::IncorrectVersion { existing, .. }) => {
+            format!("installed version: {existing}")
+        }
+    };
+
+    panic!(
+        "cairo-lang version {EXPECTED_CAIRO0_VERSION} not found ({specific_error}). Run the \
+         following commands (enter a python venv and install dependencies) and retry:\npython -m \
+         venv sequencer_venv\n. sequencer_venv/bin/activate\npip install -r {:?}",
+        PIP_REQUIREMENTS_FILE.to_str().expect("Path to requirements.txt is valid unicode.")
     );
 }

crates/apollo_infra_utils/src/cairo0_compiler.rs

@@ -0,0 +1,12 @@
+use crate::cairo0_compiler::{EXPECTED_CAIRO0_VERSION, PIP_REQUIREMENTS_FILE};
+
+#[test]
+fn test_cairo0_version_pip_requirements() {
+    let requirements_contents = std::fs::read_to_string(&*PIP_REQUIREMENTS_FILE).unwrap();
+    let pip_cairo_lang_version = requirements_contents
+        .lines()
+        .find(|line| line.starts_with("cairo-lang"))
+        .unwrap_or_else(|| panic!("Could not find cairo-lang in {:?}.", *PIP_REQUIREMENTS_FILE))
+        .trim();
+    assert_eq!(pip_cairo_lang_version, format!("cairo-lang=={EXPECTED_CAIRO0_VERSION}"));
+}

crates/apollo_infra_utils/src/cairo0_compiler_test.rs

@@ -3,7 +3,10 @@ use std::io::Write;
 use std::path::{Path, PathBuf};
 use std::process::{Command, Output};
 
-use apollo_infra_utils::cairo0_compiler::verify_cairo0_compiler_deps;
+use apollo_infra_utils::cairo0_compiler::{
+    verify_cairo0_compiler_deps,
+    STARKNET_COMPILE_DEPRECATED,
+};
 use apollo_infra_utils::cairo_compiler_version::cairo1_compiler_version;
 use apollo_infra_utils::compile_time_cargo_manifest_dir;
 use tempfile::NamedTempFile;
@@ -53,7 +56,7 @@ pub fn cairo0_compile(
     debug_info: bool,
 ) -> CompilationArtifacts {
     verify_cairo0_compiler_deps();
-    let mut command = Command::new("starknet-compile-deprecated");
+    let mut command = Command::new(STARKNET_COMPILE_DEPRECATED);
     command.arg(&path);
     if let Some(extra_arg) = extra_arg {
         command.arg(extra_arg);