1use anyhow::Result;
  2use plonky2::iop::witness::{PartialWitness, WitnessWrite};
  3use plonky2::plonk::circuit_builder::CircuitBuilder;
  4use plonky2::plonk::circuit_data::{CircuitConfig, VerifierCircuitData};
  5use plonky2::plonk::proof::ProofWithPublicInputs;
  6
  7use crate::access_set::AccessSet;
  8use crate::signal::{Digest, PlonkyProof, Signal, C, F};
  9
 10impl AccessSet {
 11    pub fn aggregate_signals(
 12        &self,
 13        topic0: Digest,
 14        signal0: Signal,
 15        topic1: Digest,
 16        signal1: Signal,
 17        verifier_data: &VerifierCircuitData<F, C, 2>,
 18    ) -> Result<(Digest, Digest, PlonkyProof, VerifierCircuitData<F, C, 2>)> {
 19        let config = CircuitConfig::standard_recursion_zk_config();
 20        let mut builder = CircuitBuilder::new(config);
 21        let mut pw = PartialWitness::new();
 22
 23        let public_inputs0: Vec<F> = self
 24            .0
 25            .cap
 26            .0
 27            .iter()
 28            .flat_map(|h| h.elements)
 29            .chain(signal0.nullifier)
 30            .chain(topic0)
 31            .collect();
 32        let public_inputs1: Vec<F> = self
 33            .0
 34            .cap
 35            .0
 36            .iter()
 37            .flat_map(|h| h.elements)
 38            .chain(signal1.nullifier)
 39            .chain(topic1)
 40            .collect();
 41
 42        let proof_target0 = builder.add_virtual_proof_with_pis(&verifier_data.common);
 43        builder.register_public_inputs(&proof_target0.public_inputs);
 44        pw.set_proof_with_pis_target(
 45            &proof_target0,
 46            &ProofWithPublicInputs {
 47                proof: signal0.proof,
 48                public_inputs: public_inputs0,
 49            },
 50        )?;
 51        let vd_target =
 52            builder.add_virtual_verifier_data(verifier_data.common.config.fri_config.cap_height);
 53        pw.set_verifier_data_target(&vd_target, &verifier_data.verifier_only)?;
 54
 55        let proof_target1 = builder.add_virtual_proof_with_pis(&verifier_data.common);
 56        builder.register_public_inputs(&proof_target1.public_inputs);
 57        pw.set_proof_with_pis_target(
 58            &proof_target1,
 59            &ProofWithPublicInputs {
 60                proof: signal1.proof,
 61                public_inputs: public_inputs1,
 62            },
 63        )?;
 64        let vd_target =
 65            builder.add_virtual_verifier_data(verifier_data.common.config.fri_config.cap_height);
 66        pw.set_verifier_data_target(&vd_target, &verifier_data.verifier_only)?;
 67
 68        pw.set_cap_target(
 69            &vd_target.constants_sigmas_cap,
 70            &verifier_data.verifier_only.constants_sigmas_cap,
 71        )?;
 72
 73        builder.verify_proof::<C>(&proof_target0, &vd_target, &verifier_data.common);
 74        builder.verify_proof::<C>(&proof_target1, &vd_target, &verifier_data.common);
 75
 76        let data = builder.build();
 77        let recursive_proof = data.prove(pw)?;
 78
 79        data.verify(recursive_proof.clone())?;
 80
 81        Ok((
 82            signal0.nullifier,
 83            signal1.nullifier,
 84            recursive_proof.proof,
 85            data.verifier_data(),
 86        ))
 87    }
 88}
 89
 90#[cfg(test)]
 91mod tests {
 92    use anyhow::Result;
 93    use plonky2::field::types::{Field, Sample};
 94    use plonky2::hash::merkle_tree::MerkleTree;
 95    use plonky2::hash::poseidon::PoseidonHash;
 96    use plonky2::plonk::config::Hasher;
 97    use plonky2::plonk::proof::ProofWithPublicInputs;
 98    use std::time::Instant;
 99
100    use crate::access_set::AccessSet;
101    use crate::signal::{Digest, F};
102
103    #[test]
104    fn test_recursion() -> Result<()> {
105        let n = 1 << 20;
106        let private_keys: Vec<Digest> = (0..n).map(|_| F::rand_array()).collect();
107        let public_keys: Vec<Vec<F>> = private_keys
108            .iter()
109            .map(|&sk| {
110                PoseidonHash::hash_no_pad(&[sk, [F::ZERO; 4]].concat())
111                    .elements
112                    .to_vec()
113            })
114            .collect();
115        let access_set = AccessSet(MerkleTree::new(public_keys, 0));
116
117        // first proof
118        let i0 = 12;
119        let topic0 = F::rand_array();
120        let start = Instant::now();
121        let (signal0, vd0) = access_set.make_signal(private_keys[i0], topic0, i0)?;
122        println!("generate proof: {:?}", start.elapsed());
123        access_set.verify_signal(topic0, signal0.clone(), &vd0)?;
124
125        // second proof
126        let i1 = 42;
127        let topic1 = F::rand_array();
128        let start = Instant::now();
129        let (signal1, vd1) = access_set.make_signal(private_keys[i1], topic1, i1)?;
130        println!("generate proof: {:?}", start.elapsed());
131        access_set.verify_signal(topic1, signal1.clone(), &vd1)?;
132
133        // generate recursive proof
134        let start = Instant::now();
135        let (nullifier0, nullifier1, recursive_proof, vd2) =
136            access_set.aggregate_signals(topic0, signal0, topic1, signal1, &vd0)?;
137        println!("aggregate_signals (recursive prove): {:?}", start.elapsed());
138
139        // verify recursive proof
140        let public_inputs: Vec<F> = access_set
141            .0
142            .cap
143            .0
144            .iter()
145            .flat_map(|h| h.elements)
146            .chain(nullifier0)
147            .chain(topic0)
148            .chain(access_set.0.cap.0.iter().flat_map(|h| h.elements))
149            .chain(nullifier1)
150            .chain(topic1)
151            .collect();
152
153        let start = Instant::now();
154        vd2.verify(ProofWithPublicInputs {
155            proof: recursive_proof,
156            public_inputs,
157        })?;
158        println!("verify recursive proof: {:?}", start.elapsed());
159        Ok(())
160    }
161}