implement run and adapt in run_and_prove (#166)

## Type

- [ ] feature
- [ ] bugfix
- [ ] dev (no functional changes, no API changes)
- [ ] fmt (formatting, renaming)
- [ ] build
- [ ] docs
- [ ] testing

## Description


## Breaking changes?

- [ ] yes
- [ ] no

<!-- Reviewable:start -->
- - -
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/starkware-libs/bootloader-hints/166)
<!-- Reviewable:end -->

Author: nitsan-starkware

crates/run_and_prove/Cargo.toml

@@ -3,4 +3,9 @@ name = "run_and_prove"
 version = "0.1.0"
 edition = "2024"
 
-[dependencies]
+[dependencies]
+cairo-vm.workspace = true
+clap.workspace = true
+thiserror.workspace = true
+cairo-program-runner-lib.workspace = true
+stwo-cairo-adapter.workspace = true

crates/run_and_prove/src/main.rs

@@ -1 +1,79 @@
-fn main() {}
+use cairo_program_runner_lib::cairo_run_program;
+use cairo_program_runner_lib::utils::{get_cairo_run_config, get_program, get_program_input};
+use cairo_vm::types::errors::program_errors::ProgramError;
+use cairo_vm::types::layout_name::LayoutName;
+use cairo_vm::vm::errors::cairo_run_errors::CairoRunError;
+use cairo_vm::vm::errors::runner_errors::RunnerError;
+use clap::Parser;
+use std::env;
+use std::path::PathBuf;
+use stwo_cairo_adapter::adapter::adapter;
+use stwo_cairo_adapter::vm_import::VmImportError;
+use thiserror::Error;
+
+#[derive(Parser, Debug)]
+#[clap(author, version, about, long_about = None)]
+struct Args {
+    // cairo run args:
+    #[clap(long = "program", help = "Path to the compiled program")]
+    program: PathBuf,
+    #[clap(long = "program_input", help = "Path to the program input file.")]
+    program_input: Option<PathBuf>,
+}
+
+#[derive(Debug, Error)]
+enum StwoRunAndProveError {
+    #[error(transparent)]
+    Cli(#[from] clap::Error),
+    #[error(transparent)]
+    IO(#[from] std::io::Error),
+    #[error(transparent)]
+    VmImport(#[from] VmImportError),
+    #[error(transparent)]
+    CairoRun(Box<CairoRunError>),
+    #[error(transparent)]
+    Program(#[from] ProgramError),
+    #[error(transparent)]
+    Runner(#[from] RunnerError),
+}
+
+// Implement From<Box<CairoRunError>> manually
+// TODO(Nitsan, 03/07/2025): check why this error is so big and if it can be boxed where it was
+// created.
+impl From<CairoRunError> for StwoRunAndProveError {
+    fn from(err: CairoRunError) -> Self {
+        StwoRunAndProveError::CairoRun(Box::new(err))
+    }
+}
+
+#[allow(unused_variables)]
+// TODO(Nitsan, 03/07/2025): The prove part is not implemented yet, so we keep this unused variable
+// to avoid warnings.
+fn main() -> Result<(), StwoRunAndProveError> {
+    let args = Args::try_parse_from(env::args())?;
+    let program = get_program(args.program.as_path())?;
+
+    let program_input_contents = get_program_input(&args.program_input)?;
+    let cairo_run_config = get_cairo_run_config(
+        // we don't use dynamic layout in stwo
+        &None,
+        LayoutName::all_cairo_stwo,
+        true,
+        // in stwo when proof_mode==true, trace padding is redundant work
+        true,
+        // we allow missing builtins because all_cairo_stwo doesn't include all builtins, and
+        // the bootloader will simulate the missing builtins.
+        true,
+        // we don't need to relocate memory in the VM because we later call the adapter that does
+        // relocation.
+        false,
+    )?;
+
+    let runner = cairo_run_program(&program, program_input_contents, cairo_run_config)?;
+    let mut prover_input_info = runner.get_prover_input_info()?;
+    let prover_input = adapter(&mut prover_input_info)?;
+
+    // TODO(Nitsan, 03/07/2025): prove will be implemented in next PR
+
+    Ok(())
+}