chore(cairo_native): make the starknet-native-compile crate a part of…

… the workspace

Cargo.toml

@@ -4,6 +4,7 @@
 resolver = "2"
 
 members = [
+  "crates/bin/starknet-native-compile",
   "crates/blockifier",
   "crates/blockifier_reexecution",
   "crates/committer_cli",
@@ -57,8 +58,6 @@ members = [
   "workspace_tests",
 ]
 
-exclude = ["crates/bin/starknet-native-compile"]
-
 [workspace.package]
 version = "0.14.0-rc.0"
 edition = "2021"

crates/bin/starknet-native-compile/Cargo.toml

@@ -1,15 +1,27 @@
 [package]
 name = "starknet-native-compile"
-# The version of this crate should equal the version of cairo-native.
-version = "0.2.5"
-edition = "2021"
-repository = "https://github.com/starkware-libs/sequencer/"
-license = "Apache-2.0"
+# Make sure this version equals the version of `cairo-native`.
+version.workspace = true
+edition.workspace = true
+repository.workspace = true
+license-file.workspace = true
+description = "A binary that compiles Sierra into Cairo native."
+
+[lints]
+workspace = true
+
+[features]
+cairo_native = [
+  "dep:cairo-lang-sierra",
+  "dep:cairo-lang-starknet-classes",
+  "dep:cairo-native",
+  "dep:clap",
+  "dep:serde_json",
+]
 
 [dependencies]
-# TODO(Avi, 01/02/2025): Check consistency with the blockifier.
-cairo-lang-sierra = "2.10.0-rc.1"
-cairo-lang-starknet-classes = "2.10.0-rc.1"
-cairo-native = { git = "https://github.com/lambdaclass/cairo_native", rev = "981093a" }
-clap = { version = "4.5.4", features = ["derive"] }
-serde_json = "1.0.116"
+cairo-lang-sierra = { workspace = true, optional = true }
+cairo-lang-starknet-classes = { workspace = true, optional = true }
+cairo-native = { workspace = true, optional = true }
+clap = { workspace = true, optional = true }
+serde_json = { workspace = true, optional = true }

crates/bin/starknet-native-compile/src/cairo_native.rs

@@ -0,0 +1,59 @@
+use std::path::PathBuf;
+use std::process;
+
+use cairo_lang_sierra::program::Program;
+use cairo_lang_starknet_classes::contract_class::ContractClass;
+use cairo_native::executor::AotContractExecutor;
+use cairo_native::OptLevel;
+use clap::Parser;
+
+#[derive(Parser, Debug)]
+#[clap(version, verbatim_doc_comment)]
+struct Args {
+    /// The path of the Sierra file to compile.
+    path: PathBuf,
+    /// The output file path.
+    output: PathBuf,
+}
+
+pub(crate) fn main() {
+    let args = Args::parse();
+    let path = args.path;
+    let output = args.output;
+
+    let (contract_class, sierra_program) = load_sierra_program_from_file(&path);
+
+    // TODO(Avi, 01/12/2024): Test different optimization levels for best performance.
+    let mut contract_executor = AotContractExecutor::new(
+        &sierra_program,
+        &contract_class.entry_points_by_type,
+        OptLevel::default(),
+    )
+    .unwrap_or_else(|err| {
+        eprintln!("Error compiling Sierra program: {}", err);
+        process::exit(1);
+    });
+    contract_executor.save(output.clone()).unwrap_or_else(|err| {
+        eprintln!("Error saving compiled program: {}", err);
+        process::exit(1);
+    });
+}
+
+fn load_sierra_program_from_file(path: &PathBuf) -> (ContractClass, Program) {
+    let raw_contract_class = std::fs::read_to_string(path).unwrap_or_else(|err| {
+        eprintln!("Error reading Sierra file: {}", err);
+        process::exit(1);
+    });
+    let contract_class: ContractClass =
+        serde_json::from_str(&raw_contract_class).unwrap_or_else(|err| {
+            eprintln!("Error deserializing Sierra file into contract class: {}", err);
+            process::exit(1);
+        });
+    (
+        contract_class.clone(),
+        contract_class.extract_sierra_program().unwrap_or_else(|err| {
+            eprintln!("Error extracting Sierra program from contract class: {}", err);
+            process::exit(1);
+        }),
+    )
+}

crates/bin/starknet-native-compile/src/main.rs

@@ -1,43 +1,14 @@
-use std::path::PathBuf;
-use std::process;
-
-use cairo_native::executor::AotContractExecutor;
-use cairo_native::OptLevel;
-use clap::Parser;
-
-use crate::utils::load_sierra_program_from_file;
-
-mod utils;
-
-#[derive(Parser, Debug)]
-#[clap(version, verbatim_doc_comment)]
-struct Args {
-    /// The path of the Sierra file to compile.
-    path: PathBuf,
-    /// The output file path.
-    output: PathBuf,
-}
+#[cfg(feature = "cairo_native")]
+mod cairo_native;
 
 fn main() {
-    // TODO(Avi, 01/12/2024): Find a way to restrict time, memory and file size during compilation.
-    let args = Args::parse();
-    let path = args.path;
-    let output = args.output;
-
-    let (contract_class, sierra_program) = load_sierra_program_from_file(&path);
-
-    // TODO(Avi, 01/12/2024): Test different optimization levels for best performance.
-    let mut contract_executor = AotContractExecutor::new(
-        &sierra_program,
-        &contract_class.entry_points_by_type,
-        OptLevel::default(),
-    )
-    .unwrap_or_else(|err| {
-        eprintln!("Error compiling Sierra program: {}", err);
-        process::exit(1);
-    });
-    contract_executor.save(output.clone()).unwrap_or_else(|err| {
-        eprintln!("Error saving compiled program: {}", err);
-        process::exit(1);
-    });
+    #[cfg(not(feature = "cairo_native"))]
+    {
+        eprintln!(
+            "The `starknet-native-compile` binary was compiled without the 'cairo_native' feature."
+        );
+        std::process::exit(1);
+    }
+    #[cfg(feature = "cairo_native")]
+    cairo_native::main();
 }

crates/starknet_sierra_multicompile/Cargo.toml

@@ -34,5 +34,9 @@ rstest.workspace = true
 starknet_infra_utils.path = "../starknet_infra_utils"
 
 [build-dependencies]
+# NOTE: This dependency is not necessary for the code to work. It is added to make the implicit
+# dependency from the build.rs appear in the dependency tree, which simplifies publishing the 
+# workspace
+starknet-native-compile.path = "../bin/starknet-native-compile"
 starknet_infra_utils.workspace = true
 tempfile.workspace = true

crates/starknet_sierra_multicompile/build.rs

@@ -15,9 +15,10 @@ fn main() {
     install_starknet_native_compile();
 }
 
-const REQUIRED_CAIRO_LANG_VERSION: &str = "2.7.1";
+const REQUIRED_CAIRO_LANG_VERSION: &str = "2.10.0-rc.1";
 #[cfg(feature = "cairo_native")]
-const REQUIRED_CAIRO_NATIVE_VERSION: &str = "0.2.5";
+// TODO(Avi, 15/2/2025): Add test that checks the version of this constant is the workspace version.
+const REQUIRED_CAIRO_NATIVE_VERSION: &str = "v0.14.0-rc.0";
 
 /// Downloads the Cairo crate from StarkWare's release page and extracts its contents into the
 /// `target` directory. This crate includes the `starknet-sierra-compile` binary, which is used to
@@ -27,7 +28,7 @@ fn install_starknet_sierra_compile() {
     let binary_name = CAIRO_LANG_BINARY_NAME;
     let required_version = REQUIRED_CAIRO_LANG_VERSION;
 
-    let cargo_install_args = &[binary_name, "--version", required_version];
+    let cargo_install_args = vec![binary_name, "--version", required_version];
     install_compiler_binary(binary_name, required_version, cargo_install_args);
 }
 
@@ -44,18 +45,30 @@ fn install_starknet_native_compile() {
         starknet_infra_utils::path::project_path().expect("Should be able to get the project path");
 
     let starknet_native_compile_crate_path = repo_root_dir.join("crates/bin").join(binary_name);
-    let starknet_native_compile_crate_path_str = starknet_native_compile_crate_path
-        .to_str()
-        .expect("Failed to convert the crate path to str");
-    println!("cargo:rerun-if-changed={}", starknet_native_compile_crate_path_str);
-
-    let cargo_install_args = &["--path", starknet_native_compile_crate_path_str];
+    let mut cargo_install_args: Vec<&str>;
+    if starknet_native_compile_crate_path.exists() {
+        println!("The crate {binary_name} is found locally - installing from local path.");
+        let starknet_native_compile_crate_path_str = starknet_native_compile_crate_path
+            .to_str()
+            .expect("Failed to convert the crate path to str");
+        println!("cargo:rerun-if-changed={}", starknet_native_compile_crate_path_str);
+
+        cargo_install_args = vec!["--path", starknet_native_compile_crate_path_str];
+    } else {
+        println!("The crate {binary_name} is not found locally - installing from crates.io.");
+        cargo_install_args = vec![binary_name, "--version", required_version];
+    }
+    cargo_install_args.append(&mut vec!["--features", "cairo_native"]);
     install_compiler_binary(binary_name, required_version, cargo_install_args);
 }
 
-fn install_compiler_binary(binary_name: &str, required_version: &str, cargo_install_args: &[&str]) {
+fn install_compiler_binary(
+    binary_name: &str,
+    required_version: &str,
+    cargo_install_args: Vec<&str>,
+) {
     let binary_path = binary_path(out_dir(), binary_name);
-    println!("cargo:rerun-if-changed={}", binary_path.to_str().unwrap());
+    println!("cargo:rerun-if-changed={}", binary_path.display());
 
     match Command::new(&binary_path).args(["--version"]).output() {
         Ok(binary_version) => {

crates/starknet_sierra_multicompile/src/compile_test.rs

@@ -49,7 +49,7 @@ fn get_faulty_test_contract() -> ContractClass {
 #[rstest]
 #[case::command_line_compiler(command_line_compiler())]
 fn test_compile_sierra_to_casm(#[case] compiler: impl SierraToCasmCompiler) {
-    let expected_casm_contract_length = 72304;
+    let expected_casm_contract_length = 72305;
 
     let contract_class = get_test_contract();
     let casm_contract = compiler.compile(contract_class).unwrap();