1//! Solidity templates for the verifier contracts.
  2//! We use askama for templating and define which variables are required for each template.
  3
  4// Pragma statements for verifiers
  5pub const PRAGMA_GROTH16_VERIFIER: &str = "pragma solidity >=0.7.0 <0.9.0;"; // from snarkjs, avoid changing
  6pub const PRAGMA_KZG10_VERIFIER: &str = "pragma solidity >=0.8.1 <=0.8.4;";
  7
  8/// Default SDPX License identifier
  9pub const GPL3_SDPX_IDENTIFIER: &str = "// SPDX-License-Identifier: GPL-3.0";
 10pub const MIT_SDPX_IDENTIFIER: &str = "// SPDX-License-Identifier: MIT";
 11use ark_serialize::{CanonicalDeserialize, CanonicalSerialize, Read, SerializationError, Write};
 12
 13pub mod g16;
 14pub mod kzg;
 15pub mod nova_cyclefold;
 16
 17pub use g16::Groth16VerifierKey;
 18pub use kzg::KZG10VerifierKey;
 19pub use nova_cyclefold::{get_decider_template_for_cyclefold_decider, NovaCycleFoldVerifierKey};
 20
 21pub trait ProtocolVerifierKey: CanonicalDeserialize + CanonicalSerialize {
 22    const PROTOCOL_NAME: &'static str;
 23
 24    fn serialize_name<W: Write>(&self, writer: &mut W) -> Result<(), SerializationError> {
 25        Self::PROTOCOL_NAME
 26            .to_string()
 27            .serialize_uncompressed(writer)
 28    }
 29
 30    fn serialize_protocol_verifier_key<W: Write>(
 31        &self,
 32        writer: &mut W,
 33    ) -> Result<(), SerializationError> {
 34        self.serialize_name(writer)?;
 35        self.serialize_compressed(writer)
 36    }
 37    fn deserialize_protocol_verifier_key<R: Read + Copy>(
 38        mut reader: R,
 39    ) -> Result<Self, SerializationError> {
 40        let name: String = String::deserialize_uncompressed(&mut reader)?;
 41        let data = Self::deserialize_compressed(&mut reader)?;
 42
 43        if name != Self::PROTOCOL_NAME {
 44            return Err(SerializationError::InvalidData);
 45        }
 46
 47        Ok(data)
 48    }
 49
 50    fn render_as_template(self, pragma: Option<String>) -> Vec<u8>;
 51}
 52
 53#[cfg(test)]
 54pub mod tests {
 55    use ark_bn254::{Bn254, Fr, G1Projective as G1};
 56    use ark_crypto_primitives::snark::CircuitSpecificSetupSNARK;
 57    use ark_ff::PrimeField;
 58    use ark_groth16::Groth16;
 59    use ark_poly_commit::kzg10::VerifierKey as KZGVerifierKey;
 60    use ark_r1cs_std::alloc::AllocVar;
 61    use ark_r1cs_std::eq::EqGadget;
 62    use ark_r1cs_std::fields::fp::FpVar;
 63    use ark_relations::r1cs::{ConstraintSynthesizer, ConstraintSystemRef, SynthesisError};
 64    use ark_std::rand::{RngCore, SeedableRng};
 65    use ark_std::test_rng;
 66    use std::marker::PhantomData;
 67
 68    use folding_schemes::commitment::{
 69        kzg::{ProverKey as KZGProverKey, KZG},
 70        CommitmentScheme,
 71    };
 72
 73    /// Default setup length for testing.
 74    pub const DEFAULT_SETUP_LEN: usize = 5;
 75
 76    /// Test circuit used to test the Groth16 proof generation
 77    #[derive(Debug, Clone, Copy)]
 78    pub struct TestAddCircuit<F: PrimeField> {
 79        _f: PhantomData<F>,
 80        pub x: u8,
 81        pub y: u8,
 82        pub z: u8,
 83    }
 84
 85    impl<F: PrimeField> ConstraintSynthesizer<F> for TestAddCircuit<F> {
 86        fn generate_constraints(self, cs: ConstraintSystemRef<F>) -> Result<(), SynthesisError> {
 87            let x = FpVar::<F>::new_witness(cs.clone(), || Ok(F::from(self.x)))?;
 88            let y = FpVar::<F>::new_witness(cs.clone(), || Ok(F::from(self.y)))?;
 89            let z = FpVar::<F>::new_input(cs.clone(), || Ok(F::from(self.z)))?;
 90            let comp_z = x.clone() + y.clone();
 91            comp_z.enforce_equal(&z)?;
 92            Ok(())
 93        }
 94    }
 95
 96    #[allow(clippy::type_complexity)]
 97    pub fn setup<'a>(
 98        n: usize,
 99    ) -> (
100        Fr, // public params hash
101        KZGProverKey<'a, G1>,
102        KZGVerifierKey<Bn254>,
103        ark_groth16::ProvingKey<Bn254>,
104        ark_groth16::VerifyingKey<Bn254>,
105        TestAddCircuit<Fr>,
106    ) {
107        let mut rng = ark_std::rand::rngs::StdRng::seed_from_u64(test_rng().next_u64());
108        let (x, y, z) = (21, 21, 42);
109        let circuit = TestAddCircuit::<Fr> {
110            _f: PhantomData,
111            x,
112            y,
113            z,
114        };
115        let (g16_pk, g16_vk) = Groth16::<Bn254>::setup(circuit, &mut rng).unwrap();
116
117        let (kzg_pk, kzg_vk): (KZGProverKey<G1>, KZGVerifierKey<Bn254>) =
118            KZG::<Bn254>::setup(&mut rng, n).unwrap();
119        let pp_hash = Fr::from(42u32); // only for test
120        (pp_hash, kzg_pk, kzg_vk, g16_pk, g16_vk, circuit)
121    }
122}