diff --git a/Scarb.toml b/Scarb.toml index de3a004cb..73d345695 100644 --- a/Scarb.toml +++ b/Scarb.toml @@ -1,6 +1,3 @@ [package] name = "cairo_verifier" version = "0.1.0" - -[lib] -sierra-text = true diff --git a/run.sh b/run.sh index ccb737935..0070727a7 100755 --- a/run.sh +++ b/run.sh @@ -2,4 +2,4 @@ scarb build cd runner -cargo run --release -- ../target/dev/cairo_verifier.sierra < resources/parserin.txt +cargo run --release -- ../target/dev/cairo_verifier.sierra.json < resources/parserin.txt diff --git a/runner/Cargo.toml b/runner/Cargo.toml index 707a80401..80145e467 100644 --- a/runner/Cargo.toml +++ b/runner/Cargo.toml @@ -7,7 +7,7 @@ edition = "2021" [dependencies] anyhow = "1.0.76" -cairo-args-runner = "0.1.1" +cairo-args-runner = "1.0.0" clap = { version = "4.4.11", features = ["derive"] } lalrpop-util = { version = "0.20.0", features = ["lexer", "unicode"] } serde = { version = "1.0.193", features = ["derive"] } diff --git a/runner/src/ast.rs b/runner/src/ast.rs index 9085ee2dc..a56e8db19 100644 --- a/runner/src/ast.rs +++ b/runner/src/ast.rs @@ -12,7 +12,7 @@ pub enum Expr { impl Display for Expr { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { - Expr::Value(v) => write!(f, "{v}"), + Expr::Value(v) => write!(f, "\"{v}\""), Expr::Array(v) => { write!(f, "[")?; @@ -26,7 +26,7 @@ impl Display for Expr { write!(f, "]")?; Ok(()) - }, + } } } } diff --git a/runner/src/main.rs b/runner/src/main.rs index 2da2c038d..5f6c7dbc4 100644 --- a/runner/src/main.rs +++ b/runner/src/main.rs @@ -1,6 +1,6 @@ use std::io::{stdin, Read}; -use cairo_args_runner::{run, WrappedArg}; +use cairo_args_runner::{run, Arg, VecFelt252}; use clap::Parser; use lalrpop_util::lalrpop_mod; @@ -23,13 +23,13 @@ fn main() -> anyhow::Result<()> { let parsed = parser::CairoParserOutputParser::new() .parse(&input) .map_err(|e| anyhow::anyhow!("{}", e))?; - let result = format!("{parsed}"); + let result = parsed.to_string(); let target = cli.target; let function = "main"; - let args: WrappedArg = serde_json::from_str(&result).unwrap(); + let args: VecFelt252 = serde_json::from_str(&result).unwrap(); - let result = run(&target, &function, &args)?; + let result = run(&target, function, &[Arg::Array(args.to_vec())])?; println!("{result:?}"); Ok(()) diff --git a/runner/src/parser.lalrpop b/runner/src/parser.lalrpop index daa655768..f63f3199e 100644 --- a/runner/src/parser.lalrpop +++ b/runner/src/parser.lalrpop @@ -11,6 +11,7 @@ CairoParserOutputInner: Exprs = { => Exprs(vec![Expr::Value(n)]), "[" > "]" => Exprs(vec![Expr::Array(n.iter().flat_map(|x| x.iter().cloned()).collect())]), StructName "()" => Exprs(Vec::new()), + "FriWitness" "(" "layers=" "[" > "]" ")" => Exprs(vec![Expr::Array(n.iter().flat_map(|x| x.iter().cloned()).collect())]), StructName "(" > ")" => Exprs(n.iter().flat_map(|x| x.iter().cloned()).collect()), }; @@ -18,6 +19,15 @@ Arg: Exprs = { ArgName "=" => n, }; +FriWitnessLayers: Exprs = { + "," "[" > "]" => Exprs(vec![Expr::Value(n)].into_iter().chain(a.into_iter().map(Expr::Value)).collect()), + StructName "(" ArgName "=" StructName "(" ")" ")" => n, +}; + +FriWitnessLayersArgs: Exprs = { + ArgName "=" "," ArgName "=" "[" > "]" => Exprs(vec![Expr::Value(n)].into_iter().chain(a.into_iter().map(Expr::Value)).collect()), +}; + Comma: Vec = { ",")*> => match e { None => v, diff --git a/src/input_structs.cairo b/src/input_structs.cairo index a87612e60..f0e05a778 100644 --- a/src/input_structs.cairo +++ b/src/input_structs.cairo @@ -1,2 +1,5 @@ +mod public_input; mod stark_config; mod stark_proof; +mod stark_unsent_commitment; +mod stark_witness; diff --git a/src/input_structs/public_input.cairo b/src/input_structs/public_input.cairo new file mode 100644 index 000000000..63250014d --- /dev/null +++ b/src/input_structs/public_input.cairo @@ -0,0 +1,16 @@ +#[derive(Drop, Serde)] +struct PublicInput { + log_n_steps: felt252, + range_check_min: felt252, + range_check_max: felt252, + layout: felt252, + dynamic_params: Array, + n_segments: felt252, + segments: Array, + padding_addr: felt252, + padding_value: felt252, + main_page_len: felt252, + main_page: Array, + n_continuous_pages: felt252, + continuous_page_headers: Array, +} diff --git a/src/input_structs/stark_config.cairo b/src/input_structs/stark_config.cairo index 4e4c27c67..92b6e4192 100644 --- a/src/input_structs/stark_config.cairo +++ b/src/input_structs/stark_config.cairo @@ -1,39 +1,39 @@ -#[derive(Copy, Drop)] +#[derive(Drop, Serde)] struct StarkConfig { traces: TracesConfig, composition: TableCommitmentConfig, -// fri: FriConfig, -// proof_of_work: ProofOfWorkConfig, -// // Log2 of the trace domain size. -// log_trace_domain_size: felt252, -// // Number of queries to the last component, FRI. -// n_queries: felt252, -// // Log2 of the number of cosets composing the evaluation domain, where the coset size is the -// // trace length. -// log_n_cosets: felt252, -// // Number of layers that use a verifier friendly hash in each commitment. -// n_verifier_friendly_commitment_layers: felt252, + fri: FriConfig, + proof_of_work: ProofOfWorkConfig, + // Log2 of the trace domain size. + log_trace_domain_size: felt252, + // Number of queries to the last component, FRI. + n_queries: felt252, + // Log2 of the number of cosets composing the evaluation domain, where the coset size is the + // trace length. + log_n_cosets: felt252, + // Number of layers that use a verifier friendly hash in each commitment. + n_verifier_friendly_commitment_layers: felt252, } -#[derive(Copy, Drop)] +#[derive(Drop, Serde)] struct TracesConfig { original: TableCommitmentConfig, interaction: TableCommitmentConfig, } -#[derive(Copy, Drop)] +#[derive(Drop, Serde)] struct TableCommitmentConfig { columns: felt252, vector: VectorCommitmentConfig } -#[derive(Copy, Drop)] +#[derive(Drop, Serde)] struct VectorCommitmentConfig { height: felt252, verifier_friendly_commitment_layers: felt252, } -#[derive(Copy, Drop)] +#[derive(Drop, Serde)] struct FriConfig { // Log2 of the size of the input layer to FRI. log_input_size: felt252, @@ -41,14 +41,14 @@ struct FriConfig { n_layers: felt252, // Array of size n_layers - 1, each entry is a configuration of a table commitment for the // corresponding inner layer. - inner_layers: TableCommitmentConfig, + inner_layers: Array, // Array of size n_layers, each entry represents the FRI step size, // i.e. the number of FRI-foldings between layer i and i+1. - fri_step_sizes: felt252, + fri_step_sizes: Array, log_last_layer_degree_bound: felt252, } -#[derive(Copy, Drop)] +#[derive(Drop, Serde)] struct ProofOfWorkConfig { // Proof of work difficulty (number of bits required to be 0). n_bits: felt252, diff --git a/src/input_structs/stark_proof.cairo b/src/input_structs/stark_proof.cairo index 01919b43b..b81942347 100644 --- a/src/input_structs/stark_proof.cairo +++ b/src/input_structs/stark_proof.cairo @@ -1,9 +1,13 @@ -use cairo_verifier::input_structs::stark_config::StarkConfig; +use cairo_verifier::input_structs::{ + stark_config::StarkConfig, public_input::PublicInput, + stark_unsent_commitment::StarkUnsentCommitment, stark_witness::StarkWitness, +}; -#[derive(Copy, Drop)] + +#[derive(Drop, Serde)] struct StarkProof { config: StarkConfig, -// public_input: PublicInput, -// unsent_commitment: StarkUnsentCommitment, -// witness: StarkWitness, + public_input: PublicInput, + unsent_commitment: StarkUnsentCommitment, + witness: StarkWitness, } diff --git a/src/input_structs/stark_unsent_commitment.cairo b/src/input_structs/stark_unsent_commitment.cairo new file mode 100644 index 000000000..737c8991b --- /dev/null +++ b/src/input_structs/stark_unsent_commitment.cairo @@ -0,0 +1,25 @@ +#[derive(Drop, Serde)] +struct StarkUnsentCommitment { + traces: TracesUnsentCommitment, + composition: felt252, + oods_values: Array, + fri: FriUnsentCommitment, + proof_of_work: ProofOfWorkUnsentCommitment, +} + +#[derive(Drop, Serde)] +struct TracesUnsentCommitment { + original: felt252, + interaction: felt252, +} + +#[derive(Drop, Serde)] +struct FriUnsentCommitment { + inner_layers: Array, + last_layer_coefficients: Array, +} + +#[derive(Drop, Serde)] +struct ProofOfWorkUnsentCommitment { + nonce: felt252, +} diff --git a/src/input_structs/stark_witness.cairo b/src/input_structs/stark_witness.cairo new file mode 100644 index 000000000..845addcbd --- /dev/null +++ b/src/input_structs/stark_witness.cairo @@ -0,0 +1,42 @@ +#[derive(Drop, Serde)] +struct StarkWitness { + traces_decommitment: TracesDecommitment, + traces_witness: TracesWitness, + interaction: TableCommitmentWitness, + composition_decommitment: TableDecommitment, + composition_witness: TableCommitmentWitness, + fri_witness: FriWitness, +} + +#[derive(Drop, Serde)] +struct TracesDecommitment { + original: TableDecommitment, + interaction: TableDecommitment, +} + +#[derive(Drop, Serde)] +struct TableDecommitment { + n_values: felt252, + values: Array, +} + +#[derive(Drop, Serde)] +struct TracesWitness { + original: TableCommitmentWitness, +} + +#[derive(Drop, Serde)] +struct TableCommitmentWitness { + vector: VectorCommitmentWitness, +} + +#[derive(Drop, Serde)] +struct VectorCommitmentWitness { + n_authentications: felt252, + authentications: Array, +} + +#[derive(Drop, Serde)] +struct FriWitness { + layers: Array, +} diff --git a/src/lib.cairo b/src/lib.cairo index 5ba23f5ea..c1d190018 100644 --- a/src/lib.cairo +++ b/src/lib.cairo @@ -8,6 +8,8 @@ mod vector_commitment; use cairo_verifier::input_structs::stark_proof::StarkProof; -fn main(stark_proof: StarkProof) -> (felt252, felt252) { - (stark_proof.config.traces.original.columns, stark_proof.config.traces.interaction.columns) + +fn main(x: Array) { + let mut x_span = x.span(); + let stark_proof: StarkProof = Serde::deserialize(ref x_span).unwrap(); }