1#[cfg(test)]
 2mod tests {
 3    use ark_bn254::{Fr, G1Projective as G1};
 4    use ark_ec::AffineRepr;
 5    use ark_grumpkin::Projective as G2;
 6    use ark_std::Zero;
 7    use rand::rngs::OsRng;
 8
 9    use arkeddsa::ed_on_bn254_twist::{constraints::EdwardsVar, EdwardsProjective};
10
11    use folding_schemes::{
12        commitment::pedersen::Pedersen,
13        folding::nova::{Nova, PreprocessorParam},
14        frontend::FCircuit,
15        transcript::poseidon::poseidon_canonical_config,
16        FoldingScheme,
17    };
18
19    use crate::{
20        fcircuit::EthDosCircuit,
21        signature::gen_signatures,
22        utils::{dbg, elapsed, get_time},
23    };
24
25    #[test]
26    fn full_flow() {
27        // set how many steps of folding we want to compute
28        const N_STEPS: usize = 10;
29        dbg(format!(
30            "running Nova folding scheme on EthDosCircuit, with N_STEPS={}",
31            N_STEPS
32        ));
33
34        let mut rng = OsRng;
35        let poseidon_config = poseidon_canonical_config::<Fr>();
36
37        let pks_sigs =
38            gen_signatures::<OsRng, EdwardsProjective>(&mut rng, &poseidon_config, N_STEPS);
39
40        // set the initial state
41        let xy = pks_sigs[0].pk.0.xy().unwrap();
42        let pk0 = vec![xy.0, xy.1];
43        let z_0: Vec<Fr> = vec![pk0.clone(), pk0, vec![Fr::zero()]].concat();
44
45        type FC = EthDosCircuit<Fr, EdwardsProjective, EdwardsVar>;
46        let f_circuit = FC::new(poseidon_config.clone()).unwrap();
47
48        // define type aliases for the FoldingScheme (FS) and Decider (D), to avoid writting the
49        // whole type each time
50        pub type FS = Nova<G1, G2, FC, Pedersen<G1>, Pedersen<G2>, false>;
51
52        // prepare the Nova prover & verifier params
53        let nova_preprocess_params =
54            PreprocessorParam::new(poseidon_config.clone(), f_circuit.clone());
55        let start = get_time();
56        let nova_params = FS::preprocess(&mut rng, &nova_preprocess_params).unwrap();
57        dbg(format!("Nova params generated: {:?}", elapsed(start)));
58
59        // initialize the folding scheme engine, in our case we use Nova
60        let mut nova = FS::init(&nova_params, f_circuit, z_0.clone()).unwrap();
61
62        // run n steps of the folding iteration
63        let start_full = get_time();
64        for i in 0..N_STEPS {
65            let start = get_time();
66            nova.prove_step(rng, pks_sigs[i].clone(), None).unwrap();
67            dbg(format!("Nova::prove_step {}: {:?}", nova.i, elapsed(start)));
68        }
69        dbg(format!(
70            "Nova's all {} steps time: {:?}",
71            N_STEPS,
72            elapsed(start_full)
73        ));
74
75        // verify the last IVC proof
76        let ivc_proof = nova.ivc_proof();
77        dbg!(&ivc_proof.z_i);
78        FS::verify(
79            nova_params.1.clone(), // Nova's verifier params
80            ivc_proof,
81        )
82        .unwrap();
83    }
84}