Scarb execute name change, arguments file, error msgs (#1888)

maciektr · web-flow · commit ee7f7a2bbf45 · 2025-01-17T15:35:00.000Z
- **Rename scarb-cairo-execute to scarb-execute**
- **Support reading arguments from file in scarb execute**
- **Unify error messages in scarb execute**
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -3,7 +3,7 @@ members = [
     "scarb",
     "scarb-metadata",
     "extensions/scarb-doc",
-    "extensions/scarb-cairo-execute",
+    "extensions/scarb-execute",
     "extensions/scarb-cairo-language-server",
     "extensions/scarb-cairo-run",
     "extensions/scarb-cairo-test",
diff --git a/extensions/scarb-cairo-run/src/main.rs b/extensions/scarb-cairo-run/src/main.rs
@@ -111,7 +111,7 @@ fn main_inner(ui: &Ui, args: Args) -> Result<()> {
     ensure!(
         path.exists(),
         formatdoc! {r#"
-            package has not been compiled, file does not exist: {filename}
+            package has not been compiled, file does not exist: `{filename}`
             help: run `scarb build` to compile the package
         "#}
     );
diff --git a/extensions/scarb-cairo-run/tests/examples.rs b/extensions/scarb-cairo-run/tests/examples.rs
@@ -58,13 +58,13 @@ fn build_can_be_skipped() {
 
     #[cfg(windows)]
     snapbox.stdout_eq(indoc! {r#"
-            error: package has not been compiled, file does not exist: hello_world.sierra.json
+            error: package has not been compiled, file does not exist: `hello_world.sierra.json`
             help: run `scarb build` to compile the package
             error: process did not exit successfully: exit code: 1
         "#});
     #[cfg(not(windows))]
     snapbox.stdout_eq(indoc! {r#"
-            error: package has not been compiled, file does not exist: hello_world.sierra.json
+            error: package has not been compiled, file does not exist: `hello_world.sierra.json`
             help: run `scarb build` to compile the package
         "#});
 }
diff --git a/extensions/scarb-execute/Cargo.toml b/extensions/scarb-execute/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "scarb-cairo-execute"
+name = "scarb-execute"
 publish = false
 
 authors.workspace = true
@@ -15,6 +15,7 @@ anyhow.workspace = true
 bincode.workspace = true
 cairo-lang-executable.workspace = true
 cairo-lang-runner.workspace = true
+cairo-lang-utils.workspace = true
 cairo-vm.workspace = true
 camino.workspace = true
 clap.workspace = true
diff --git a/extensions/scarb-execute/src/main.rs b/extensions/scarb-execute/src/main.rs
@@ -2,6 +2,7 @@ use anyhow::{bail, ensure, Context, Result};
 use bincode::enc::write::Writer;
 use cairo_lang_executable::executable::{EntryPointKind, Executable};
 use cairo_lang_runner::{build_hints_dict, Arg, CairoHintProcessor};
+use cairo_lang_utils::bigint::BigUintAsHex;
 use cairo_vm::cairo_run::cairo_run_program;
 use cairo_vm::cairo_run::CairoRunConfig;
 use cairo_vm::types::layout_name::LayoutName;
@@ -48,9 +49,8 @@ struct Args {
 
 #[derive(Parser, Clone, Debug)]
 struct ExecutionArgs {
-    /// Serialized arguments to the executable function.
-    #[arg(long, value_delimiter = ',')]
-    arguments: Vec<BigInt>,
+    #[command(flatten)]
+    pub arguments: ProgramArguments,
 
     /// Desired execution output, either default Standard or CairoPie
     #[arg(long, default_value = "standard")]
@@ -65,6 +65,37 @@ struct ExecutionArgs {
     print_program_output: bool,
 }
 
+#[derive(Parser, Debug, Clone)]
+pub struct ProgramArguments {
+    /// Serialized arguments to the executable function.
+    #[arg(long, value_delimiter = ',')]
+    arguments: Vec<BigInt>,
+
+    /// Serialized arguments to the executable function from a file.
+    #[arg(long, conflicts_with = "arguments")]
+    arguments_file: Option<Utf8PathBuf>,
+}
+
+impl ProgramArguments {
+    pub fn read_arguments(self) -> Result<Vec<Arg>> {
+        if let Some(path) = self.arguments_file {
+            let file = fs::File::open(&path).with_context(|| "reading arguments file failed")?;
+            let as_vec: Vec<BigUintAsHex> = serde_json::from_reader(file)
+                .with_context(|| "deserializing arguments file failed")?;
+            Ok(as_vec
+                .into_iter()
+                .map(|v| Arg::Value(v.value.into()))
+                .collect())
+        } else {
+            Ok(self
+                .arguments
+                .iter()
+                .map(|v| Arg::Value(v.into()))
+                .collect())
+        }
+    }
+}
+
 #[derive(ValueEnum, Clone, Debug)]
 enum OutputFormat {
     CairoPie,
@@ -142,7 +173,7 @@ fn main_inner(args: Args, ui: Ui) -> Result<(), anyhow::Error> {
             .entrypoints
             .iter()
             .find(|e| matches!(e.kind, EntryPointKind::Standalone))
-            .with_context(|| "No `Standalone` entrypoint found.")?;
+            .with_context(|| "no `Standalone` entrypoint found")?;
         Program::new_for_proof(
             entrypoint.builtins.clone(),
             data,
@@ -159,7 +190,7 @@ fn main_inner(args: Args, ui: Ui) -> Result<(), anyhow::Error> {
             .entrypoints
             .iter()
             .find(|e| matches!(e.kind, EntryPointKind::Bootloader))
-            .with_context(|| "No `Bootloader` entrypoint found.")?;
+            .with_context(|| "no `Bootloader` entrypoint found")?;
         Program::new(
             entrypoint.builtins.clone(),
             data,
@@ -171,17 +202,11 @@ fn main_inner(args: Args, ui: Ui) -> Result<(), anyhow::Error> {
             None,
         )
     }
-    .with_context(|| "Failed setting up program.")?;
+    .with_context(|| "failed setting up program")?;
 
     let mut hint_processor = CairoHintProcessor {
         runner: None,
-        user_args: vec![vec![Arg::Array(
-            args.run
-                .arguments
-                .iter()
-                .map(|v| Arg::Value(v.into()))
-                .collect(),
-        )]],
+        user_args: vec![vec![Arg::Array(args.run.arguments.read_arguments()?)]],
         string_to_hint,
         starknet_state: Default::default(),
         run_resources: Default::default(),
@@ -203,12 +228,12 @@ fn main_inner(args: Args, ui: Ui) -> Result<(), anyhow::Error> {
         .with_context(|| "Cairo program run failed")?;
 
     if args.run.print_program_output {
-        let mut output_buffer = "Program Output:\n".to_string();
+        let mut output_buffer = "Program output:\n".to_string();
         runner.vm.write_output(&mut output_buffer)?;
-        print!("{output_buffer}");
+        ui.print(output_buffer.trim_end());
     }
 
-    let output_dir = scarb_target_dir.join("scarb-execute");
+    let output_dir = scarb_target_dir.join("execute");
     create_output_dir(output_dir.as_std_path())?;
 
     if args.run.output.is_cairo_pie() {
@@ -231,7 +256,7 @@ fn main_inner(args: Args, ui: Ui) -> Result<(), anyhow::Error> {
         let relocated_trace = runner
             .relocated_trace
             .as_ref()
-            .with_context(|| "Trace not relocated.")?;
+            .with_context(|| "trace not relocated")?;
         let mut writer = FileWriter::new(3 * 1024 * 1024, &trace_path)?;
         cairo_run::write_encoded_trace(relocated_trace, &mut writer)?;
         writer.flush()?;
@@ -253,7 +278,7 @@ fn main_inner(args: Args, ui: Ui) -> Result<(), anyhow::Error> {
             .get_air_private_input()
             .to_serializable(trace_path.to_string(), memory_path.to_string())
             .serialize_json()
-            .with_context(|| "Failed serializing private input.")?;
+            .with_context(|| "failed serializing private input")?;
         fs::write(air_private_input_path, output_value)?;
     }
 
@@ -275,14 +300,14 @@ fn load_prebuilt_executable(path: &Utf8Path, filename: String) -> Result<Executa
     ensure!(
         file_path.exists(),
         formatdoc! {r#"
-            package has not been compiled, file does not exist: {filename}
+            package has not been compiled, file does not exist: `{filename}`
             help: run `scarb build` to compile the package
         "#}
     );
     let file = fs::File::open(&file_path)
-        .with_context(|| format!("failed to open executable program: {file_path}"))?;
+        .with_context(|| format!("failed to open executable program: `{file_path}`"))?;
     serde_json::from_reader(file)
-        .with_context(|| format!("failed to deserialize executable program: {file_path}"))
+        .with_context(|| format!("failed to deserialize executable program: `{file_path}`"))
 }
 
 fn incremental_create_output_file(
@@ -294,7 +319,7 @@ fn incremental_create_output_file(
         path,
         name,
         extension,
-        "Failed to create output directory.",
+        "failed to create output directory",
         |p| {
             OpenOptions::new()
                 .write(true)
@@ -306,7 +331,7 @@ fn incremental_create_output_file(
 }
 
 fn incremental_create_output_dir(path: &Utf8Path, name: String) -> Result<Utf8PathBuf> {
-    incremental_attempt_io_creation(path, name, "", "Failed to create output directory.", |p| {
+    incremental_attempt_io_creation(path, name, "", "failed to create output directory", |p| {
         fs::create_dir(p)
     })
 }
diff --git a/extensions/scarb-execute/tests/arguments.rs b/extensions/scarb-execute/tests/arguments.rs
@@ -0,0 +1,84 @@
+use assert_fs::fixture::{FileWriteStr, PathChild};
+use assert_fs::TempDir;
+use indoc::indoc;
+use scarb_test_support::command::Scarb;
+use scarb_test_support::project_builder::ProjectBuilder;
+
+#[test]
+fn can_take_big_number_as_arg() {
+    let t = TempDir::new().unwrap();
+
+    ProjectBuilder::start()
+        .name("hello")
+        .version("0.1.0")
+        .manifest_extra(indoc! {r#"
+            [executable]
+        "#})
+        .dep_cairo_execute()
+        .lib_cairo(indoc! {r#"
+        #[executable]
+        fn main(a: felt252, b: felt252) -> felt252 {
+            b
+        }
+        "#})
+        .build(&t);
+
+    Scarb::quick_snapbox()
+        .arg("execute")
+        .arg("--print-program-output")
+        .arg("--arguments")
+        .arg(r#"1,1129815197211541481934112806673325772687763881719835256646064516195041515616"#)
+        .current_dir(&t)
+        .assert()
+        .success()
+        .stdout_matches(indoc! {r#"
+            [..]Compiling hello v0.1.0 ([..]/Scarb.toml)
+            [..]Finished `dev` profile target(s) in [..]
+            [..]Executing hello
+            Program output:
+            0
+            1129815197211541481934112806673325772687763881719835256646064516195041515616
+            Saving output to: target/execute/hello
+        "#});
+}
+
+#[test]
+fn can_read_arguments_from_file() {
+    let t = TempDir::new().unwrap();
+
+    ProjectBuilder::start()
+        .name("hello")
+        .version("0.1.0")
+        .manifest_extra(indoc! {r#"
+            [executable]
+        "#})
+        .dep_cairo_execute()
+        .lib_cairo(indoc! {r#"
+        #[executable]
+        fn main(a: felt252, b: felt252) -> felt252 {
+            b
+        }
+        "#})
+        .build(&t);
+
+    t.child("args.txt")
+        .write_str(r#"["0x1","0x27F73E6C94FA8249EC9F2F4EEC607ACC97FA632C9E8FB6C49437E62390D9860"]"#)
+        .unwrap();
+
+    Scarb::quick_snapbox()
+        .arg("execute")
+        .arg("--print-program-output")
+        .args(["--arguments-file", "args.txt"])
+        .current_dir(&t)
+        .assert()
+        .success()
+        .stdout_matches(indoc! {r#"
+            [..]Compiling hello v0.1.0 ([..]/Scarb.toml)
+            [..]Finished `dev` profile target(s) in [..]
+            [..]Executing hello
+            Program output:
+            0
+            1129815197211541481934112806673325772687763881719835256646064516195041515616
+            Saving output to: target/execute/hello
+        "#});
+}
diff --git a/extensions/scarb-execute/tests/build.rs b/extensions/scarb-execute/tests/build.rs
