Poseidon hasher for channel

.tool-versions

@@ -1 +1 @@
-scarb 2.4.3
+scarb 2.6.0

Cargo.toml

@@ -7,17 +7,18 @@ edition = "2021"
 version = "0.1.0"
 
 [workspace.dependencies]
-anyhow = "1.0.79"
-cairo-args-runner = "1.0.1"
+anyhow = "1"
 cairo-felt = "0.9"
-cairo-lang-runner = "2.5.0"
-cairo-lang-sierra = "2.5.0"
-cairo-lang-utils = "2.5.0"
-cairo-proof-parser = { git = "https://github.com/cartridge-gg/cairo-proof-parser", tag = "v0.1.0" }
-cairo-vm = "0.9.2"
-clap = { version = "4.4.18", features = ["derive"] }
+cairo-lang-casm = "=2.6.0"
+cairo-lang-runner = "=2.6.0"
+cairo-lang-sierra = "=2.6.0"
+cairo-lang-utils = "=2.6.0"
+cairo-proof-parser = { git = "https://github.com/Okm165/cairo-proof-parser" }
+cairo-vm = "=0.9.2"
+clap = { version = "4.5.2", features = ["derive"] }
 itertools = "0.12.0"
-num-bigint = "0.4"
-serde = { version = "1.0.196", features = ["derive"] }
-serde_json = "1.0.113"
-thiserror = "1.0"
+num-bigint = "0.4.4"
+runner = { path = "runner" }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+thiserror = "1.0"

README.md

@@ -101,6 +101,14 @@ cpu_air_prover \
 
 You can `verify` this the proof `locally` or on the `Starknet Cairo verifier` contract by specifying the path `examples/proofs/fibonacci_proof.json` to the newly generated proof.
 
+## Benchmarking
+
+In order to launch benchmarking just run this:
+
+```bash
+cargo run --release --bin benches -- target/dev/cairo_verifier.sierra.json
+```
+
 ## Changing the Hasher
 
 By default, the verifier uses Pedersen for verifier-friendly layers and Keccak for unfriendly layers. To change the hasher for unfriendly layers, use the provided Python script:

benches/src/bench.rs

@@ -1,43 +1,22 @@
 use cairo_lang_runner::{
-    build_hints_dict, CairoHintProcessor, RunResult, SierraCasmRunner, StarknetState,
+    ProfilingInfoCollectionConfig, RunResultStarknet, RunnerError, SierraCasmRunner,
 };
 use cairo_lang_sierra::program::Program;
 use cairo_lang_utils::ordered_hash_map::OrderedHashMap;
-use cairo_vm::vm::runners::cairo_runner::RunResources;
-use itertools::chain;
 
-pub fn bench(sierra_program: Program, function: &str) -> anyhow::Result<RunResult> {
-    let sierra_runner = SierraCasmRunner::new(
-        sierra_program,
+pub fn bench(sierra_program: Program, function: &str) -> Result<RunResultStarknet, RunnerError> {
+    let runner = SierraCasmRunner::new(
+        sierra_program.clone(),
         Some(Default::default()),
         OrderedHashMap::default(),
-        true,
-    )?;
-
-    let func = sierra_runner.find_function(function)?;
-    let initial_gas = sierra_runner.get_initial_available_gas(func, Some(usize::MAX))?;
-    let (entry_code, builtins) = sierra_runner.create_entry_code(func, &[], initial_gas)?;
-    let footer = SierraCasmRunner::create_code_footer();
-    let (hints_dict, string_to_hint) = build_hints_dict(chain!(
-        entry_code.iter(),
-        sierra_runner.get_casm_program().instructions.iter()
-    ));
-    let assembled_program = sierra_runner
-        .get_casm_program()
-        .assemble_ex(&entry_code, &footer);
-
-    let mut hint_processor = CairoHintProcessor {
-        runner: Some(&sierra_runner),
-        starknet_state: StarknetState::default(),
-        string_to_hint,
-        run_resources: RunResources::default(),
-    };
-
-    Ok(sierra_runner.run_function(
+        Some(ProfilingInfoCollectionConfig::default()),
+    )
+    .unwrap();
+    let func = runner.find_function(function).unwrap();
+    runner.run_function_with_starknet_context(
         func,
-        &mut hint_processor,
-        hints_dict,
-        assembled_program.bytecode.iter(),
-        builtins,
-    )?)
+        &[],
+        Some(u32::MAX as usize),
+        Default::default(),
+    )
 }

benches/src/main.rs

@@ -36,14 +36,9 @@ fn main() -> anyhow::Result<()> {
         println!("Function: {f_name}");
         // println!("---------------------------------");
         // println!("Gas Used        : {}", result.gas_counter.unwrap());
-        println!("Execution Steps : {}", result.memory.len());
+        println!("Number of steps : {}", result.memory.len());
         // println!("Return Value    : {:#?}", result.value);
         println!("---------------------------------\n");
-
-        // let profiling_processor = ProfilingInfoProcessor::new(sierra_program.program);
-        // let processed_profiling_info = profiling_processor.process(&profiling_info.unwrap());
-
-        // println!("profiling: {}", processed_profiling_info);
     });
 
     Ok(())

examples/starknet/Cargo.toml

@@ -7,8 +7,9 @@ edition = "2021"
 
 [dependencies]
 anyhow.workspace = true
-cairo-args-runner.workspace = true
-clap.workspace = true
 cairo-proof-parser.workspace = true
-serde.workspace = true
-serde_json.workspace = true
+clap.workspace = true
+itertools.workspace = true
+runner.workspace = true
+serde_json.workspace = true
+serde.workspace = true

examples/starknet/src/main.rs

@@ -1,13 +1,27 @@
-use cairo_args_runner::VecFelt252;
 use cairo_proof_parser::parse;
+use itertools::{chain, Itertools};
+use runner::VecFelt252;
 use std::io::{stdin, Read};
 
 fn main() -> anyhow::Result<()> {
     let mut input = String::new();
     stdin().read_to_string(&mut input)?;
 
-    let exprs = parse(input)?.to_string();
-    let proof: VecFelt252 = serde_json::from_str(&exprs).unwrap();
+    let parsed = parse(input)?;
+
+    let config: VecFelt252 = serde_json::from_str(&parsed.config.to_string()).unwrap();
+    let public_input: VecFelt252 = serde_json::from_str(&parsed.public_input.to_string()).unwrap();
+    let unsent_commitment: VecFelt252 =
+        serde_json::from_str(&parsed.unsent_commitment.to_string()).unwrap();
+    let witness: VecFelt252 = serde_json::from_str(&parsed.witness.to_string()).unwrap();
+
+    let proof = chain!(
+        config.to_vec(),
+        public_input.to_vec(),
+        unsent_commitment.to_vec(),
+        witness.to_vec()
+    )
+    .collect_vec();
 
     let proof_string = proof
         .iter()

runner/Cargo.toml

@@ -7,8 +7,16 @@ edition.workspace = true
 
 [dependencies]
 anyhow.workspace = true
-cairo-args-runner.workspace = true
-clap.workspace = true
+cairo-felt.workspace = true
+cairo-lang-casm.workspace = true
+cairo-lang-runner.workspace = true
+cairo-lang-sierra.workspace = true
+cairo-lang-utils.workspace = true
 cairo-proof-parser.workspace = true
-serde.workspace = true
+cairo-vm.workspace = true
+clap.workspace = true
+itertools.workspace = true
+num-bigint.workspace = true
 serde_json.workspace = true
+serde.workspace = true
+thiserror.workspace = true

runner/src/lib.rs

@@ -0,0 +1,2 @@
+pub mod vec252;
+pub use vec252::VecFelt252;

runner/src/main.rs

@@ -1,7 +1,16 @@
-use clap::Parser;
-use std::io::{stdin, Read};
+mod vec252;
+use crate::vec252::VecFelt252;
+
+use cairo_lang_runner::{Arg, ProfilingInfoCollectionConfig, SierraCasmRunner};
+use cairo_lang_sierra::program::VersionedProgram;
+use cairo_lang_utils::ordered_hash_map::OrderedHashMap;
 use cairo_proof_parser::parse;
-use cairo_args_runner::{Arg, Felt252, VecFelt252};
+use clap::Parser;
+use itertools::{chain, Itertools};
+use std::{
+    fs,
+    io::{stdin, Read},
+};
 
 #[derive(Parser)]
 #[command(author, version, about, long_about = None)]
@@ -11,23 +20,56 @@ struct Cli {
 }
 
 fn main() -> anyhow::Result<()> {
-    let args = Cli::parse();
+    let cli = Cli::parse();
     let mut input = String::new();
     stdin().read_to_string(&mut input)?;
-    let exprs = parse(input)?.to_string();
+    let parsed = parse(input)?;
 
-    let result = run(exprs, args.target)?;
-    println!("{result:?}");
+    let target = cli.target;
+    let function = "main";
 
-    Ok(())
-}
+    let config: VecFelt252 = serde_json::from_str(&parsed.config.to_string()).unwrap();
+    let public_input: VecFelt252 = serde_json::from_str(&parsed.public_input.to_string()).unwrap();
+    let unsent_commitment: VecFelt252 =
+        serde_json::from_str(&parsed.unsent_commitment.to_string()).unwrap();
+    let witness: VecFelt252 = serde_json::from_str(&parsed.witness.to_string()).unwrap();
 
-fn run(parsed: String, target: String) -> anyhow::Result<Vec<Felt252>> {
-    let function = "main";
-    let args: VecFelt252 = serde_json::from_str(&parsed).unwrap();
-    Ok(cairo_args_runner::run(
-        &target,
-        function,
-        &[Arg::Array(args.to_vec())],
-    )?)
+    let proof = chain!(
+        config.to_vec(),
+        public_input.to_vec(),
+        unsent_commitment.to_vec(),
+        witness.to_vec()
+    )
+    .collect_vec();
+
+    println!("proof size: {} felts", proof.len());
+
+    let sierra_program =
+        serde_json::from_str::<VersionedProgram>(&fs::read_to_string(target)?)?.into_v1()?;
+
+    let runner = SierraCasmRunner::new(
+        sierra_program.program.clone(),
+        Some(Default::default()),
+        OrderedHashMap::default(),
+        Some(ProfilingInfoCollectionConfig::default()),
+    )
+    .unwrap();
+    let func = runner.find_function(function).unwrap();
+    let result = runner
+        .run_function_with_starknet_context(
+            func,
+            &[Arg::Array(proof.to_vec())],
+            Some(u32::MAX as usize),
+            Default::default(),
+        )
+        .unwrap();
+    // let profiling_processor =
+    //     ProfilingInfoProcessor::new(None, sierra_program.program, UnorderedHashMap::default());
+    // let processed_profiling_info = profiling_processor.process(&result.profiling_info.unwrap());
+
+    println!("gas_counter: {}", result.gas_counter.unwrap());
+    println!("n_steps: {}", result.memory.len());
+    println!("return: {:#?}", result.value);
+
+    Ok(())
 }