Merge pull request #127 from HerodotusDev/better_cairo_runners

5 - better cairo-vm runners

Author: Okm165

.env.example

@@ -0,0 +1,4 @@
+RPC_URL_ETHEREUM= 
+RPC_URL_FEEDER_GATEWAY=https://alpha-sepolia.starknet.io/feeder_gateway/
+RPC_URL_HERODOTUS_INDEXER=https://grower-indexer.api.herodotus.cloud/accumulators/proofs/
+RPC_URL_STARKNET= 

Cargo.lock

@@ -18,7 +18,8 @@ source venv/bin/activate
 
 ## Running
 
-Before running the program, prepare the input data. The inputs are provided via the `hdp_input.json` file located in the root directory of the HDP project.
+Before running the program, prepare the input data. The inputs are provided via the [hdp_input.json](examples/hdp_input.json).
+Runtime require chain nodes RPC calls, ensure an environment variables [.env.example](.env.example) are set.
 
 ### Steps to Execute:
 
@@ -34,7 +35,7 @@ Before running the program, prepare the input data. The inputs are provided via
 
 3. **Run Cairo1 Module with Verified On-Chain Data:**
    ```bash
-   cargo run --release --bin sound_run -- --program_input examples/hdp_input.json --program_proofs hdp_proofs.json --program_output hdp_output.json --layout starknet_with_keccak
+   cargo run --release --bin sound_run -- --program_input examples/hdp_input.json --program_proofs hdp_proofs.json --print_output --layout starknet_with_keccak --cairo_pie_output pie.zip
    ```
 
 The program will output the results root and tasks root. These roots can be used to extract the results from the on-chain contract.
@@ -60,7 +61,7 @@ The overall program is split into two main parts:
 
 ## Testing
 
-Some tests require chain nodes RPC calls. Ensure an environment variable named `ETH_RPC` and `STARKNET_RPC` is set.
+Tests require chain nodes RPC calls. Ensure an environment variables [.env.example](.env.example) are set.
 
 1. **Build Cairo1 Modules:**
    ```bash

README.md

@@ -53,7 +53,7 @@ impl SyscallHandler for CallContractHandler {
                 .map_err(|e| SyscallExecutionError::InternalError(format!("{}", e).into()))?,
         ));
 
-        let retdata_start = vm.add_temporary_segment();
+        let retdata_start = vm.add_memory_segment();
         let mut retdata_end = retdata_start;
 
         match call_handler_id {

crates/dry_hint_processor/src/syscall_handler/evm/mod.rs

@@ -47,7 +47,7 @@ impl SyscallHandler for CallContractHandler {
                 .map_err(|e| SyscallExecutionError::InternalError(format!("{}", e).into()))?,
         ));
 
-        let retdata_start = vm.add_temporary_segment();
+        let retdata_start = vm.add_memory_segment();
         let mut retdata_end = retdata_start;
 
         match call_handler_id {

crates/dry_hint_processor/src/syscall_handler/starknet/mod.rs

@@ -9,7 +9,6 @@ clap.workspace = true
 dry_hint_processor.workspace = true
 hints.workspace = true
 serde_json.workspace = true
-thiserror.workspace = true
 tokio.workspace = true
 tracing-subscriber.workspace = true
 tracing.workspace = true

crates/dry_run/Cargo.toml

@@ -4,12 +4,8 @@
 #![forbid(unsafe_code)]
 
 use cairo_vm::{
-    cairo_run::CairoRunConfig,
-    types::{layout_name::LayoutName, program::Program},
-    vm::{
-        errors::vm_exception::VmException,
-        runners::cairo_runner::{CairoRunner, RunnerMode},
-    },
+    cairo_run::{self, cairo_run_program},
+    types::{layout::CairoLayoutParams, layout_name::LayoutName, program::Program},
 };
 use clap::Parser;
 use dry_hint_processor::{
@@ -19,70 +15,101 @@ use dry_hint_processor::{
 use hints::vars;
 use std::{env, path::PathBuf};
 use tracing::debug;
-use types::HDPDryRunInput;
+use types::{error::Error, HDPDryRunInput};
 
 #[derive(Parser, Debug)]
 #[clap(author, version, about, long_about = None)]
 struct Args {
-    #[clap(long = "layout", default_value = "plain", value_enum)]
-    layout: LayoutName,
-    #[structopt(long = "proof_mode")]
-    proof_mode: bool,
     #[structopt(long = "program_input")]
     program_input: PathBuf,
     #[structopt(long = "program_output")]
     program_output: PathBuf,
+    #[clap(long = "trace_file", value_parser)]
+    trace_file: Option<PathBuf>,
+    #[structopt(long = "print_output")]
+    print_output: bool,
+    #[structopt(long = "memory_file")]
+    memory_file: Option<PathBuf>,
+    /// When using dynamic layout, it's parameters must be specified through a layout params file.
+    #[clap(long = "layout", default_value = "plain", value_enum)]
+    layout: LayoutName,
+    /// Required when using with dynamic layout.
+    /// Ignored otherwise.
+    #[clap(long = "cairo_layout_params_file", required_if_eq("layout", "dynamic"))]
+    cairo_layout_params_file: Option<PathBuf>,
+    #[structopt(long = "proof_mode")]
+    proof_mode: bool,
+    #[structopt(long = "secure_run")]
+    secure_run: Option<bool>,
+    #[clap(long = "air_public_input", requires = "proof_mode")]
+    air_public_input: Option<PathBuf>,
+    #[clap(
+        long = "air_private_input",
+        requires_all = ["proof_mode", "trace_file", "memory_file"]
+    )]
+    air_private_input: Option<PathBuf>,
+    #[clap(
+        long = "cairo_pie_output",
+        // We need to add these air_private_input & air_public_input or else
+        // passing cairo_pie_output + either of these without proof_mode will not fail
+        conflicts_with_all = ["proof_mode", "air_private_input", "air_public_input"]
+    )]
+    cairo_pie_output: Option<PathBuf>,
+    #[structopt(long = "allow_missing_builtins")]
+    allow_missing_builtins: Option<bool>,
 }
 
 #[tokio::main(flavor = "multi_thread", worker_threads = 1)]
-async fn main() -> Result<(), HdpOsError> {
+async fn main() -> Result<(), Error> {
     tracing_subscriber::fmt::init();
 
-    let args = Args::try_parse_from(std::env::args()).map_err(HdpOsError::Args)?;
+    let args = Args::try_parse_from(std::env::args()).map_err(Error::Cli)?;
+
+    let cairo_layout_params = match args.cairo_layout_params_file {
+        Some(file) => Some(CairoLayoutParams::from_file(&file)?),
+        None => None,
+    };
 
     // Init CairoRunConfig
-    let cairo_run_config = CairoRunConfig {
+    let cairo_run_config = cairo_run::CairoRunConfig {
+        trace_enabled: args.trace_file.is_some() || args.air_public_input.is_some(),
+        relocate_mem: args.memory_file.is_some() || args.air_public_input.is_some(),
         layout: args.layout,
-        relocate_mem: true,
-        trace_enabled: true,
+        proof_mode: args.proof_mode,
+        secure_run: args.secure_run,
+        allow_missing_builtins: args.allow_missing_builtins,
+        dynamic_layout_params: cairo_layout_params,
         ..Default::default()
     };
 
     // Locate the compiled program file in the `OUT_DIR` folder.
     let out_dir = PathBuf::from(env::var("OUT_DIR").expect("OUT_DIR is not set"));
     let program_file_path = out_dir.join("cairo").join("compiled.json");
 
-    let program_file = std::fs::read(program_file_path).map_err(HdpOsError::IO)?;
-    let program_inputs: HDPDryRunInput = serde_json::from_slice(&std::fs::read(args.program_input).map_err(HdpOsError::IO)?)?;
+    let program_file = std::fs::read(program_file_path).map_err(Error::IO)?;
+    let program_inputs: HDPDryRunInput = serde_json::from_slice(&std::fs::read(args.program_input).map_err(Error::IO)?)?;
 
     // Load the Program
-    let program = Program::from_bytes(&program_file, Some(cairo_run_config.entrypoint)).map_err(|e| HdpOsError::Runner(e.into()))?;
+    let program = Program::from_bytes(&program_file, Some(cairo_run_config.entrypoint))?;
 
-    let runner_mode = if cairo_run_config.proof_mode {
-        RunnerMode::ProofModeCairo1
-    } else {
-        RunnerMode::ExecutionMode
-    };
-
-    // Init cairo runner
-    let mut cairo_runner = CairoRunner::new_v2(&program, cairo_run_config.layout, None, runner_mode, cairo_run_config.trace_enabled)
-        .map_err(|e| HdpOsError::Runner(e.into()))?;
-
-    // Init the Cairo VM
-    let end = cairo_runner
-        .initialize(cairo_run_config.allow_missing_builtins.unwrap_or(false))
-        .map_err(|e| HdpOsError::Runner(e.into()))?;
-
-    // Run the Cairo VM
     let mut hint_processor = CustomHintProcessor::new(program_inputs);
-    cairo_runner
-        .run_until_pc(end, &mut hint_processor)
-        .map_err(|err| VmException::from_vm_error(&cairo_runner, err))
-        .map_err(|e| HdpOsError::Runner(e.into()))?;
+    let mut cairo_runner = cairo_run_program(&program, &cairo_run_config, &mut hint_processor).unwrap();
 
-    cairo_runner.vm.compute_segments_effective_sizes();
     debug!("{:?}", cairo_runner.get_execution_resources());
 
+    if args.print_output {
+        let mut output_buffer = "Program Output:\n".to_string();
+        cairo_runner.vm.write_output(&mut output_buffer)?;
+        print!("{output_buffer}");
+    }
+
+    if let Some(ref file_name) = args.cairo_pie_output {
+        cairo_runner
+            .get_cairo_pie()
+            .map_err(|e| Error::CairoPie(e.to_string()))?
+            .write_zip_file(file_name)?
+    }
+
     std::fs::write(
         args.program_output,
         serde_json::to_vec::<SyscallHandler>(
@@ -94,26 +121,9 @@ async fn main() -> Result<(), HdpOsError> {
                 .try_read()
                 .unwrap(),
         )
-        .map_err(|e| HdpOsError::IO(e.into()))?,
+        .map_err(|e| Error::IO(e.into()))?,
     )
-    .map_err(HdpOsError::IO)?;
+    .map_err(Error::IO)?;
 
     Ok(())
 }
-
-use cairo_vm::vm::errors::cairo_run_errors::CairoRunError;
-use thiserror::Error;
-
-#[derive(Error, Debug)]
-pub enum HdpOsError {
-    #[error(transparent)]
-    Args(#[from] clap::error::Error),
-    #[error("Runner Error: {0}")]
-    Runner(CairoRunError),
-    #[error("Output Error: {0}")]
-    Output(String),
-    #[error(transparent)]
-    IO(#[from] std::io::Error),
-    #[error(transparent)]
-    SerdeJson(#[from] serde_json::Error),
-}

crates/dry_run/src/main.rs

@@ -57,7 +57,7 @@ impl traits::SyscallHandler for CallContractHandler {
 
         let memorizer = Memorizer::derive(vm, &mut calldata)?;
 
-        let retdata_start = vm.add_temporary_segment();
+        let retdata_start = vm.add_memory_segment();
         let mut retdata_end = retdata_start;
 
         match call_handler_id {

crates/sound_hint_processor/src/syscall_handler/evm/mod.rs

@@ -51,7 +51,7 @@ impl traits::SyscallHandler for CallContractHandler {
 
         let memorizer = Memorizer::derive(vm, &mut calldata)?;
 
-        let retdata_start = vm.add_temporary_segment();
+        let retdata_start = vm.add_memory_segment();
         let mut retdata_end = retdata_start;
 
         match call_handler_id {

crates/sound_hint_processor/src/syscall_handler/starknet/mod.rs

@@ -8,7 +8,6 @@ cairo-vm.workspace = true
 clap.workspace = true
 serde_json.workspace = true
 sound_hint_processor.workspace = true
-thiserror.workspace = true
 tokio.workspace = true
 tracing-subscriber.workspace = true
 tracing.workspace = true