Calldata generator

Author: fmkra

runner/src/main.rs

@@ -5,6 +5,7 @@ use crate::vec252::VecFelt252;
 use cairo_lang_runner::{Arg, ProfilingInfoCollectionConfig, RunResultValue, SierraCasmRunner};
 use cairo_lang_sierra::program::VersionedProgram;
 use cairo_lang_utils::ordered_hash_map::OrderedHashMap;
+use cairo_vm::Felt252;
 use clap::Parser;
 use itertools::{chain, Itertools};
 use runner::{CairoVersion, HasherBitLength, StoneVersion};
@@ -13,9 +14,9 @@ use std::{
     io::{stdin, Read},
 };
 use swiftness_proof_parser::parse;
-use transform::StarkProofExprs;
+use transform::{Expr, StarkProofExprs};
 
-const ENTRYPOINT: &str = "main";
+const ENTRYPOINT: &str = "get_calldata";
 
 #[derive(Parser)]
 #[command(author, version, about)]
@@ -45,6 +46,19 @@ fn main() -> anyhow::Result<()> {
         serde_json::from_str(&stark_proof.public_input.to_string()).unwrap();
     let unsent_commitment: VecFelt252 =
         serde_json::from_str(&stark_proof.unsent_commitment.to_string()).unwrap();
+    let last_layer_commitment: VecFelt252 =
+        serde_json::from_str(&stark_proof.unsent_commitment[5].to_string()).unwrap();
+
+    let fri_witness = stark_proof.witness.last().expect("No fri witness").clone();
+    let fri_witness = split_array(fri_witness);
+    let steps = fri_witness.chunks(2).map(|chunk| {
+        chunk
+            .into_iter()
+            .flatten()
+            .map(|s| Felt252::from_dec_str(s).unwrap().to_hex_string())
+            .join(" ")
+    }).collect_vec();
+
     let witness: VecFelt252 = serde_json::from_str(&stark_proof.witness.to_string()).unwrap();
 
     let proof = chain!(
@@ -84,7 +98,25 @@ fn main() -> anyhow::Result<()> {
 
     match result.value {
         RunResultValue::Success(msg) => {
-            println!("{:?}", msg);
+            let (const_state, mut variable_state, fact_hash) = extract_calldata_from_memory(result.memory, &msg);
+
+            let const_state_str = const_state.iter().map(|x| x.to_hex_string()).join(" ");
+
+            let last_variable_state = variable_state.pop().unwrap();
+
+            for (var, step) in variable_state.iter().zip_eq(steps.iter()) {
+                let v = var.iter().map(|x| x.to_hex_string()).join(" ");
+                println!("\nSTEP");
+                println!("{} {} {}", const_state_str, v, step);
+            }
+
+            println!("\nFINAL");
+            println!("{} {} 0x{:x} {}",
+                const_state_str,
+                last_variable_state.iter().map(|x| x.to_hex_string()).join(" "),
+                last_layer_commitment.len(),
+                last_layer_commitment.iter().map(|x| x.to_hex_string()).join(" ")
+            );
         }
         RunResultValue::Panic(msg) => {
             panic!("{:?}", msg);
@@ -93,3 +125,75 @@ fn main() -> anyhow::Result<()> {
 
     Ok(())
 }
+
+fn extract_calldata_from_memory(memory: Vec<Option<Felt252>>, output: &Vec<Felt252>) -> (Vec<Felt252>, Vec<Vec<Felt252>>, Felt252) {
+    let mut output_iter = output.iter();
+
+    let mut calldata_constant_state: Vec<Felt252> = vec![];
+    calldata_constant_state.push(*output_iter.next().unwrap()); // n_layers
+    append_memory_segment(&mut calldata_constant_state, &memory, output_iter.next_tuple().unwrap(), 6); // commitment
+    append_memory_segment(&mut calldata_constant_state, &memory, output_iter.next_tuple().unwrap(), 1); // eval_points
+    append_memory_segment(&mut calldata_constant_state, &memory, output_iter.next_tuple().unwrap(), 1); // step_sizes
+    calldata_constant_state.push(*output_iter.next().unwrap()); // last_layer_coefficients_hash
+
+    let mut variable_state_ptr: Vec<Felt252> = vec![];
+    append_memory_segment(&mut variable_state_ptr, &memory, output_iter.next_tuple().unwrap(), 1); // variable_state
+    let variable_state_iter = variable_state_ptr.iter().skip(1);
+    let mut calldata_variable_state: Vec<Vec<Felt252>> = vec![];
+    for mut x in &variable_state_iter.chunks(3) {
+        let (iteration, begin, end) = x.next_tuple().unwrap();
+        let begin: usize = begin.to_biguint().try_into().unwrap();
+        let end: usize = end.to_biguint().try_into().unwrap();
+        let len = (end - begin) / 3;
+        let mut calldata = vec![];
+        calldata.push(*iteration);
+        calldata.push(len.into());
+        for x in memory[begin..end].iter() {
+            calldata.push(x.unwrap());
+        }
+        calldata_variable_state.push(calldata);
+    }
+
+    let fact_hash = *output_iter.next().unwrap();
+
+    (calldata_constant_state, calldata_variable_state, fact_hash)
+}
+
+fn append_memory_segment(calldata: &mut Vec<Felt252>, memory: &Vec<Option<Felt252>>, (&start, &end): (&Felt252, &Felt252), size: usize) {
+    let start: usize = start.to_biguint().try_into().unwrap();
+    let end: usize = end.to_biguint().try_into().unwrap();
+    let len = (end - start) / size;
+    calldata.push(len.into());
+    for addr in start..end {
+        calldata.push(memory[addr].unwrap());
+    }
+}
+
+fn split_array(expr: Expr) -> Vec<Vec<String>> {
+    match expr {
+        Expr::Array(arr) => {
+            let mut acc: Vec<Vec<String>> = vec![];
+            let mut curr: Vec<String> = vec![];
+            let mut it: u32 = 0;
+            for elem in arr {
+                if let Expr::Value(val) = elem {
+                    if it == 0 {
+                        if curr.len() > 0 {
+                            acc.push(curr);
+                        }
+                        it = val.parse().expect("Not a number");
+                        curr = vec![val];
+                    } else {
+                        curr.push(val);
+                        it -= 1;
+                    }
+                }
+            }
+            if curr.len() > 0 {
+                acc.push(curr);
+            }
+            acc
+        }
+        _ => panic!("Not an array"),
+    }
+}

src/fri/fri.cairo

@@ -263,7 +263,7 @@ fn hash_array(mut array: Span<felt252>) -> felt252 {
 // TODO: probably commitment can be moved to separate struct StateFinalize together with
 // last_layer_coefficients
 
-#[derive(Drop, Serde)]
+#[derive(Drop, Serde, Clone)]
 struct FriVerificationStateConstant {
     n_layers: u32,
     commitment: Span<TableCommitment>,
@@ -295,7 +295,7 @@ fn hash_constant(state: @FriVerificationStateConstant) -> felt252 {
     }
 }
 
-#[derive(Drop, Serde)]
+#[derive(Drop, Serde, Clone)]
 struct FriVerificationStateVariable {
     iter: u32,
     queries: Span<FriLayerQuery>,

src/lib.cairo

@@ -56,3 +56,46 @@ fn main(mut serialized: Span<felt252>, settings: @VerifierSettings) -> (felt252,
 
     (program_hash, output_hash)
 }
+
+use cairo_verifier::fri::fri::{FriVerificationStateConstant, FriVerificationStateVariable};
+use core::poseidon::{Poseidon, PoseidonImpl, HashStateImpl};
+
+struct Calldata {
+    const_state: FriVerificationStateConstant,
+    variable_state: Span<FriVerificationStateVariable>,
+    fact_hash: felt252,
+}
+
+fn get_calldata(mut serialized: Span<felt252>, settings: @VerifierSettings) -> Calldata {
+    let stark_proof_serde = Serde::<StarkProofWithSerde>::deserialize(ref serialized).unwrap();
+    let stark_proof: StarkProof = stark_proof_serde.into();
+    let (program_hash, output_hash) = match settings.cairo_version {
+        CairoVersion::Cairo0 => stark_proof.public_input.verify_cairo0(),
+        CairoVersion::Cairo1 => stark_proof.public_input.verify_cairo1(),
+    };
+
+    let mut variable_states = array![];
+
+    let fact_hash = PoseidonImpl::new().update(program_hash).update(output_hash).finalize();
+    
+    let (mut const_state, mut variable_state, last_layer_coefficients, _) = stark_proof
+        .verify_initial(0.try_into().unwrap(), 0.try_into().unwrap(), settings);
+
+    for witness in stark_proof.witness.fri_witness.layers {
+        variable_states.append(variable_state.clone());
+        let (new_const_state, new_variable_state) = StarkProofImpl::verify_step(
+            const_state, variable_state, *witness, settings
+        );
+        variable_state = new_variable_state;
+        const_state = new_const_state;
+    };
+
+    variable_states.append(variable_state.clone());
+    StarkProofImpl::verify_final(const_state.clone(), variable_state, last_layer_coefficients);
+
+    Calldata {
+        const_state,
+        variable_state: variable_states.span(),
+        fact_hash,
+    }
+}