Improve sierra2casm-dbg (#1206)

* Add sierra2casm-dbg

* Sync cairo version between sierra2casm-dbg and root

* Bump Cairo VM version in sierra2casm-dbg

* Fix compilation and linter errors

* Bump Cairo in sierra2casm-dbg

* Remove unused serde dep in sierra2casm-dbg

* Remove Rust toolchain in sierra2casm-dbg

* Add sierra2casm-dbg CI job (#1201)

* Move cairo-lang dependencies to workspace

* Remove sierra-emu/.gitignore

* Update lock

* Add fibonacci.cairo example for sierra emulator

* Simplify Makefile

* Simplify README and improve documentation on how to use the binary

* Add make check

* Improve examples

* Document make check

* Remove unused script

* Add fibonacci_contract.cairo

* Fix typo in Makefile

* Fix CI

* Use cairo2/corelib instead of corelib for symlinking in sierra emu

* Improve Sierra Emulator descritopn

* Move more dependencies to workspace

* Rename to casm-data-flow

* Add Makefile

* Add basic run-contract example

* Add fibonacci_starknet.cairo

* Fix hint format

* Add basic README.md

* Update dependencies

* Print gas usage

* Finish README.md

* Add .PHONY

* Fix paragraph

* Move deps to workspace

* Fix whitespace

* Fix whitespace

* Fix README.md

---------

Co-authored-by: gabrielbosio <gabrielbosio95@gmail.com>
Co-authored-by: Gabriel Bosio <38794644+gabrielbosio@users.noreply.github.com>

Author: JulianGCalderon

.github/workflows/ci.yml

@@ -375,8 +375,8 @@ jobs:
     - name: Retreive cached dependecies
       uses: Swatinem/rust-cache@v2
     - name: Build
-      working-directory: ./debug_utils/sierra2casm-dbg
+      working-directory: ./debug_utils/casm-data-flow
       run: cargo build --all-features --verbose
     - name: Run tests
-      working-directory: ./debug_utils/sierra2casm-dbg
+      working-directory: ./debug_utils/casm-data-flow
       run: cargo test

Cargo.lock

@@ -179,9 +179,10 @@ name = "libfuncs"
 harness = false
 
 [workspace]
-members = ["debug_utils/sierra-emu", "debug_utils/sierra2casm-dbg"]
+members = ["debug_utils/sierra-emu", "debug_utils/casm-data-flow"]
 
 [workspace.dependencies]
+cairo-lang-casm = "=2.12.0-dev.1"
 cairo-lang-compiler = "=2.12.0-dev.1"
 cairo-lang-defs = "=2.12.0-dev.1"
 cairo-lang-filesystem = "=2.12.0-dev.1"

Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "casm-data-flow"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+bincode = { version = "2.0.0-rc.3", default-features = false }
+clap = { version = "4.5.27", features = ["derive"] }
+serde_json = "1.0.138"
+starknet-types-core.workspace = true
+cairo-lang-casm = { workspace = true, features = [ "serde", ] }
+cairo-lang-utils.workspace = true
+cairo-lang-starknet-classes.workspace = true
+cairo-vm = { git = "https://github.com/lambdaclass/cairo-vm/", rev = "3b36cd92f68f3dc26ddf5aba6c1f9a50ff3d303f", features = ["cairo-1-hints"] }

debug_utils/casm-data-flow/Cargo.toml

@@ -0,0 +1,19 @@
+usage:
+	@echo "Usage:"
+	@echo "    build: Builds casm-data-flow."
+	@echo "    check: Checks format and lints."
+	@echo "    clean: Cleans the built artifacts."
+.PHONY: usage
+
+build:
+	cargo build --release --all-features
+.PHONY: build
+
+check:
+	cargo fmt --all -- --check
+	cargo clippy --all-targets --all-features -- -D warnings
+.PHONY: check
+
+clean:
+	cargo clean
+.PHONY: clean

debug_utils/casm-data-flow/Makefile

@@ -0,0 +1,52 @@
+# Casm Data Flow
+
+A data flow analyzer for a Cairo VM. Currently, it only supports starknet contracts.
+
+It is useful when trying to debug a gas difference between Cairo Native and Cairo VM.
+
+## Usage
+
+First, we need to compile the contract:
+
+```bash
+../../cairo2/bin/starknet-compile -s programs/fibonacci_starknet.cairo > programs/fibonacci_starknet.sierra.json
+../../cairo2/bin/starknet-sierra-compile programs/fibonacci_starknet.sierra.json programs/fibonacci_starknet.casm.json
+```
+
+Then, we execute the contract. In this example, we are using [our Cairo VM](https://github.com/lambdaclass/cairo-vm).
+
+```bash
+cargo run --example run-contract -- programs/fibonacci_starknet.casm.json programs/fibonacci_starknet.memory programs/fibonacci_starknet.trace
+```
+
+The example prints the starting and final gas:
+
+```
+Starting Gas: 18446744073709551615
+Final Gas: 18446744073709544205
+```
+
+We will need the trace and memory files generated, to find a path from the starting gas to the final gas.
+
+```bash
+cargo run -- --program-path programs/fibonacci_starknet.casm.json --trace-path programs/fibonacci_starknet.trace --memory-path programs/fibonacci_starknet.memory -s 18446744073709551615 -t 18446744073709544205
+```
+
+The binary prints the full path from the starting gas to the final gas.
+
+```
+  [184] = 18446744073709551615
+  [212] = 18446744073709550345 (Δ-1270)
+  [222] = 18446744073709549075 (Δ-1270)
+  [232] = 18446744073709547805 (Δ-1270)
+  [242] = 18446744073709546535 (Δ-1270)
+  [252] = 18446744073709545265 (Δ-1270)
+  [262] = 18446744073709543995 (Δ-1270)
+  [272] = 18446744073709542725 (Δ-1270)
+  [282] = 18446744073709541455 (Δ-1270)
+  [292] = 18446744073709540185 (Δ-1270)
+  [302] = 18446744073709538915 (Δ-1270)
+  [312] = 18446744073709537645 (Δ-1270)
+  [315] = 18446744073709539715 (Δ2070)
+  [321] = 18446744073709544205 (Δ4490)
+```

debug_utils/casm-data-flow/README.md

@@ -1,5 +1,5 @@
 use bincode::de::read::SliceReader;
-use sierra2casm_dbg::{decode_instruction, GraphMappings, Memory, Trace, ValueId};
+use casm_data_flow::{decode_instruction, GraphMappings, Memory, Trace, ValueId};
 use std::{collections::HashMap, fs};
 
 fn main() {

debug_utils/sierra2casm-dbg/examples/basic.rs renamed to debug_utils/casm-data-flow/examples/basic.rs

@@ -0,0 +1,174 @@
+use std::{fs::File, io::Write, path::PathBuf};
+
+use bincode::enc::write::Writer;
+use cairo_lang_starknet_classes::casm_contract_class::CasmContractClass;
+use cairo_vm::{
+    cairo_run::{write_encoded_memory, write_encoded_trace},
+    hint_processor::cairo_1_hint_processor::hint_processor::Cairo1HintProcessor,
+    types::{
+        builtin_name::BuiltinName, layout_name::LayoutName, program::Program,
+        relocatable::MaybeRelocatable,
+    },
+    vm::runners::cairo_runner::{CairoArg, CairoRunner, RunResources},
+};
+use clap::Parser;
+use starknet_types_core::felt::Felt;
+
+#[derive(Debug, Parser)]
+struct Args {
+    contract_path: PathBuf,
+    memory_path: PathBuf,
+    trace_path: PathBuf,
+}
+
+pub fn main() {
+    let cli_args = Args::parse();
+    let calldata_args = [MaybeRelocatable::from(10)];
+    let expected_retdata = [Felt::from(89)];
+
+    let contract_file = File::open(cli_args.contract_path).expect("failed to open contract path");
+    let contract: CasmContractClass =
+        serde_json::from_reader(contract_file).expect("failed to parse contract file");
+
+    let program = Program::try_from(contract.clone())
+        .expect("failed to build vm program from contract class");
+
+    let mut runner =
+        CairoRunner::new(&program, LayoutName::all_cairo, None, false, true, false).unwrap();
+
+    let program_builtins = contract
+        .entry_points_by_type
+        .external
+        .iter()
+        .find(|e| e.offset == 0)
+        .unwrap()
+        .builtins
+        .iter()
+        .map(|s| BuiltinName::from_str(s).expect("Invalid builtin name"))
+        .collect::<Vec<_>>();
+    runner
+        .initialize_function_runner_cairo_1(&program_builtins)
+        .unwrap();
+
+    let syscall_segment = MaybeRelocatable::from(runner.vm.add_memory_segment());
+
+    let builtins = runner.get_program_builtins();
+
+    let builtin_segment: Vec<MaybeRelocatable> = runner
+        .vm
+        .get_builtin_runners()
+        .iter()
+        .filter(|b| builtins.contains(&b.name()))
+        .flat_map(|b| b.initial_stack())
+        .collect();
+
+    let initial_gas = MaybeRelocatable::from(usize::MAX);
+    println!("Starting Gas: {}", &initial_gas);
+
+    let mut implicit_args = builtin_segment;
+    implicit_args.extend([initial_gas]);
+    implicit_args.extend([syscall_segment]);
+
+    let builtin_costs: Vec<MaybeRelocatable> =
+        vec![0.into(), 0.into(), 0.into(), 0.into(), 0.into()];
+    let builtin_costs_ptr = runner.vm.add_memory_segment();
+    runner
+        .vm
+        .load_data(builtin_costs_ptr, &builtin_costs)
+        .unwrap();
+
+    let core_program_end_ptr =
+        (runner.program_base.unwrap() + runner.get_program().data_len()).unwrap();
+    let program_extra_data: Vec<MaybeRelocatable> =
+        vec![0x208B7FFF7FFF7FFE.into(), builtin_costs_ptr.into()];
+    runner
+        .vm
+        .load_data(core_program_end_ptr, &program_extra_data)
+        .unwrap();
+
+    let calldata_start = runner.vm.add_memory_segment();
+    let calldata_end = runner.vm.load_data(calldata_start, &calldata_args).unwrap();
+
+    let mut entrypoint_args: Vec<CairoArg> = implicit_args
+        .iter()
+        .map(|m| CairoArg::from(m.clone()))
+        .collect();
+    entrypoint_args.extend([
+        MaybeRelocatable::from(calldata_start).into(),
+        MaybeRelocatable::from(calldata_end).into(),
+    ]);
+    let entrypoint_args: Vec<&CairoArg> = entrypoint_args.iter().collect();
+
+    let mut hint_processor =
+        Cairo1HintProcessor::new(&contract.hints, RunResources::new(621), false);
+
+    runner
+        .run_from_entrypoint(
+            0,
+            &entrypoint_args,
+            true,
+            Some(runner.get_program().data_len() + program_extra_data.len()),
+            &mut hint_processor,
+        )
+        .expect("failed to execute contract");
+
+    let return_values = runner.vm.get_return_values(5).unwrap();
+    let final_gas = return_values[0].get_int().unwrap();
+    let retdata_start = return_values[3].get_relocatable().unwrap();
+    let retdata_end = return_values[4].get_relocatable().unwrap();
+    let retdata: Vec<Felt> = runner
+        .vm
+        .get_integer_range(retdata_start, (retdata_end - retdata_start).unwrap())
+        .unwrap()
+        .iter()
+        .map(|c| c.clone().into_owned())
+        .collect();
+
+    println!("Final Gas: {}", final_gas);
+
+    assert_eq!(retdata, expected_retdata);
+
+    runner.relocate(true).expect("failed to relocate trace");
+
+    let trace_file = File::create(cli_args.trace_path).expect("failed to create trace file");
+    let mut trace_writer = FileWriter::new(trace_file);
+    write_encoded_trace(
+        &runner.relocated_trace.expect("trace should exist"),
+        &mut trace_writer,
+    )
+    .expect("failed to write trace");
+
+    let memory_file = File::create(cli_args.memory_path).expect("failed to create memory file");
+    let mut memory_writer = FileWriter::new(memory_file);
+    write_encoded_memory(&runner.relocated_memory, &mut memory_writer)
+        .expect("failed to write memory");
+}
+
+struct FileWriter {
+    buf_writer: File,
+    bytes_written: usize,
+}
+
+impl Writer for FileWriter {
+    fn write(&mut self, bytes: &[u8]) -> Result<(), bincode::error::EncodeError> {
+        self.buf_writer
+            .write_all(bytes)
+            .map_err(|e| bincode::error::EncodeError::Io {
+                inner: e,
+                index: self.bytes_written,
+            })?;
+
+        self.bytes_written += bytes.len();
+
+        Ok(())
+    }
+}
+
+impl FileWriter {
+    fn new(buf_writer: File) -> Self {
+        Self {
+            buf_writer,
+            bytes_written: 0,
+        }
+    }
+}

debug_utils/casm-data-flow/examples/run-contract.rs

@@ -0,0 +1,17 @@
+#[starknet::contract]
+mod Fibonacci {
+    #[storage]
+    struct Storage { }
+
+    #[external(v0)]
+    fn fibonacci(ref self: ContractState, value: felt252) -> felt252 {
+        return super::fibonacci(1, 1, value);
+    }
+}
+
+fn fibonacci(a: felt252, b: felt252, n: felt252) -> felt252 {
+    match n {
+        0 => a,
+        _ => fibonacci(b, a + b, n - 1),
+    }
+}