sonobe/examples/circom_full_flow.rs
examples/circom_full_flow.rsRaw
1#![allow(non_snake_case)]
2#![allow(non_camel_case_types)]
3#![allow(clippy::upper_case_acronyms)]
4///
5/// This example performs the full flow:
6/// - define the circuit to be folded
7/// - fold the circuit with Nova+CycleFold's IVC
8/// - generate a DeciderEthCircuit final proof
9/// - generate the Solidity contract that verifies the proof
10/// - verify the proof in the EVM
11///
12use ark_bn254::{constraints::GVar, Bn254, Fr, G1Projective as G1};
13
14use ark_groth16::Groth16;
15use ark_grumpkin::{constraints::GVar as GVar2, Projective as G2};
16
17use std::path::PathBuf;
18use std::time::Instant;
19
20use folding_schemes::{
21 commitment::{kzg::KZG, pedersen::Pedersen},
22 folding::nova::{
23 decider_eth::{prepare_calldata, Decider as DeciderEth},
24 Nova, PreprocessorParam,
25 },
26 frontend::{circom::CircomFCircuit, FCircuit},
27 transcript::poseidon::poseidon_canonical_config,
28 Decider, FoldingScheme,
29};
30use solidity_verifiers::{
31 evm::{compile_solidity, Evm},
32 utils::get_function_selector_for_nova_cyclefold_verifier,
33 verifiers::nova_cyclefold::get_decider_template_for_cyclefold_decider,
34 NovaCycleFoldVerifierKey,
35};
36
37fn main() {
38 // set the initial state
39 let z_0 = vec![Fr::from(3_u32)];
40
41 // set the external inputs to be used at each step of the IVC, it has length of 10 since this
42 // is the number of steps that we will do
43 let external_inputs = vec![
44 vec![Fr::from(6u32), Fr::from(7u32)],
45 vec![Fr::from(8u32), Fr::from(9u32)],
46 vec![Fr::from(10u32), Fr::from(11u32)],
47 vec![Fr::from(12u32), Fr::from(13u32)],
48 vec![Fr::from(14u32), Fr::from(15u32)],
49 vec![Fr::from(6u32), Fr::from(7u32)],
50 vec![Fr::from(8u32), Fr::from(9u32)],
51 vec![Fr::from(10u32), Fr::from(11u32)],
52 vec![Fr::from(12u32), Fr::from(13u32)],
53 vec![Fr::from(14u32), Fr::from(15u32)],
54 ];
55
56 // initialize the Circom circuit
57 let r1cs_path = PathBuf::from(
58 "./folding-schemes/src/frontend/circom/test_folder/with_external_inputs.r1cs",
59 );
60 let wasm_path = PathBuf::from(
61 "./folding-schemes/src/frontend/circom/test_folder/with_external_inputs_js/with_external_inputs.wasm",
62 );
63
64 let f_circuit_params = (r1cs_path.into(), wasm_path.into(), 1, 2);
65 let f_circuit = CircomFCircuit::<Fr>::new(f_circuit_params).unwrap();
66
67 pub type N =
68 Nova<G1, GVar, G2, GVar2, CircomFCircuit<Fr>, KZG<'static, Bn254>, Pedersen<G2>, false>;
69 pub type D = DeciderEth<
70 G1,
71 GVar,
72 G2,
73 GVar2,
74 CircomFCircuit<Fr>,
75 KZG<'static, Bn254>,
76 Pedersen<G2>,
77 Groth16<Bn254>,
78 N,
79 >;
80
81 let poseidon_config = poseidon_canonical_config::<Fr>();
82 let mut rng = rand::rngs::OsRng;
83
84 // prepare the Nova prover & verifier params
85 let nova_preprocess_params = PreprocessorParam::new(poseidon_config, f_circuit.clone());
86 let nova_params = N::preprocess(&mut rng, &nova_preprocess_params).unwrap();
87
88 // initialize the folding scheme engine, in our case we use Nova
89 let mut nova = N::init(&nova_params, f_circuit.clone(), z_0).unwrap();
90
91 // prepare the Decider prover & verifier params
92 let (decider_pp, decider_vp) =
93 D::preprocess(&mut rng, nova_params.clone(), nova.clone()).unwrap();
94
95 // run n steps of the folding iteration
96 for (i, external_inputs_at_step) in external_inputs.iter().enumerate() {
97 let start = Instant::now();
98 nova.prove_step(rng, external_inputs_at_step.clone(), None)
99 .unwrap();
100 println!("Nova::prove_step {}: {:?}", i, start.elapsed());
101 }
102
103 // verify the last IVC proof
104 let ivc_proof = nova.ivc_proof();
105 N::verify(
106 nova_params.1, // Nova's verifier params
107 ivc_proof,
108 )
109 .unwrap();
110
111 let start = Instant::now();
112 let proof = D::prove(rng, decider_pp, nova.clone()).unwrap();
113 println!("generated Decider proof: {:?}", start.elapsed());
114
115 let verified = D::verify(
116 decider_vp.clone(),
117 nova.i,
118 nova.z_0.clone(),
119 nova.z_i.clone(),
120 &nova.U_i,
121 &nova.u_i,
122 &proof,
123 )
124 .unwrap();
125 assert!(verified);
126 println!("Decider proof verification: {}", verified);
127
128 // Now, let's generate the Solidity code that verifies this Decider final proof
129 let function_selector =
130 get_function_selector_for_nova_cyclefold_verifier(nova.z_0.len() * 2 + 1);
131
132 let calldata: Vec<u8> = prepare_calldata(
133 function_selector,
134 nova.i,
135 nova.z_0,
136 nova.z_i,
137 &nova.U_i,
138 &nova.u_i,
139 proof,
140 )
141 .unwrap();
142
143 // prepare the setup params for the solidity verifier
144 let nova_cyclefold_vk = NovaCycleFoldVerifierKey::from((decider_vp, f_circuit.state_len()));
145
146 // generate the solidity code
147 let decider_solidity_code = get_decider_template_for_cyclefold_decider(nova_cyclefold_vk);
148
149 // verify the proof against the solidity code in the EVM
150 let nova_cyclefold_verifier_bytecode = compile_solidity(&decider_solidity_code, "NovaDecider");
151 let mut evm = Evm::default();
152 let verifier_address = evm.create(nova_cyclefold_verifier_bytecode);
153 let (_, output) = evm.call(verifier_address, calldata.clone());
154 assert_eq!(*output.last().unwrap(), 1);
155
156 // save smart contract and the calldata
157 println!("storing nova-verifier.sol and the calldata into files");
158 use std::fs;
159 fs::write(
160 "./examples/nova-verifier.sol",
161 decider_solidity_code.clone(),
162 )
163 .unwrap();
164 fs::write("./examples/solidity-calldata.calldata", calldata.clone()).unwrap();
165 let s = solidity_verifiers::utils::get_formatted_calldata(calldata.clone());
166 fs::write("./examples/solidity-calldata.inputs", s.join(",\n")).expect("");
167}