1use std::ops::Deref;
  2
  3use crate::utils::encoding::{g1_to_fq_repr, g2_to_fq_repr};
  4/// Solidity templates for the verifier contracts.
  5/// We use askama for templating and define which variables are required for each template.
  6use crate::utils::encoding::{G1Repr, G2Repr};
  7use ark_bn254::{Bn254, G1Affine};
  8use ark_groth16::VerifyingKey;
  9use ark_poly_commit::kzg10::VerifierKey;
 10use askama::Template;
 11
 12#[derive(Template, Default)]
 13#[template(path = "groth16_verifier.askama.sol", ext = "sol")]
 14pub struct Groth16Verifier {
 15    /// SPDX-License-Identifier
 16    pub sdpx: String,
 17    /// The `pragma` statement.
 18    pub pragma_version: String,
 19    /// The `alpha * G`, where `G` is the generator of `G1`.
 20    pub vkey_alpha_g1: G1Repr,
 21    /// The `alpha * H`, where `H` is the generator of `G2`.
 22    pub vkey_beta_g2: G2Repr,
 23    /// The `gamma * H`, where `H` is the generator of `G2`.
 24    pub vkey_gamma_g2: G2Repr,
 25    /// The `delta * H`, where `H` is the generator of `G2`.
 26    pub vkey_delta_g2: G2Repr,
 27    /// Length of the `gamma_abc_g1` vector.
 28    pub gamma_abc_len: usize,
 29    /// The `gamma^{-1} * (beta * a_i + alpha * b_i + c_i) * H`, where `H` is the generator of `E::G1`.
 30    pub gamma_abc_g1: Vec<G1Repr>,
 31}
 32
 33impl Groth16Verifier {
 34    pub fn from(value: VerifyingKey<Bn254>, pragma: Option<String>) -> Self {
 35        let pragma_version = pragma.unwrap_or_default();
 36        let sdpx = "// SPDX-License-Identifier: GPL-3.0".to_string();
 37        Self {
 38            pragma_version,
 39            sdpx,
 40            vkey_alpha_g1: g1_to_fq_repr(value.alpha_g1),
 41            vkey_beta_g2: g2_to_fq_repr(value.beta_g2),
 42            vkey_gamma_g2: g2_to_fq_repr(value.gamma_g2),
 43            vkey_delta_g2: g2_to_fq_repr(value.delta_g2),
 44            gamma_abc_len: value.gamma_abc_g1.len(),
 45            gamma_abc_g1: value
 46                .gamma_abc_g1
 47                .iter()
 48                .copied()
 49                .map(g1_to_fq_repr)
 50                .collect(),
 51        }
 52    }
 53}
 54
 55#[derive(Template, Default)]
 56#[template(path = "kzg10_verifier.askama.sol", ext = "sol")]
 57pub struct KZG10Verifier {
 58    /// SPDX-License-Identifier
 59    pub sdpx: String,
 60    /// The `pragma` statement.
 61    pub pragma_version: String,
 62    /// The generator of `G1`.
 63    pub g1: G1Repr,
 64    /// The generator of `G2`.
 65    pub g2: G2Repr,
 66    /// The verification key
 67    pub vk: G2Repr,
 68    /// Length of the trusted setup vector.
 69    pub g1_crs_len: usize,
 70    /// The trusted setup vector.
 71    pub g1_crs: Vec<G1Repr>,
 72}
 73
 74impl KZG10Verifier {
 75    pub fn from(
 76        vk: &VerifierKey<Bn254>,
 77        crs: &[G1Affine],
 78        pragma: Option<String>,
 79        sdpx: Option<String>,
 80    ) -> KZG10Verifier {
 81        let g1_string_repr = g1_to_fq_repr(vk.g);
 82        let g2_string_repr = g2_to_fq_repr(vk.h);
 83        let vk_string_repr = g2_to_fq_repr(vk.beta_h);
 84        let g1_crs_len = crs.len();
 85        let g1_crs = crs.iter().map(|g1| g1_to_fq_repr(*g1)).collect();
 86        let sdpx = sdpx.unwrap_or_default();
 87        let pragma_version = pragma.unwrap_or_default();
 88        KZG10Verifier {
 89            sdpx,
 90            pragma_version,
 91            g1: g1_string_repr,
 92            g2: g2_string_repr,
 93            vk: vk_string_repr,
 94            g1_crs,
 95            g1_crs_len,
 96        }
 97    }
 98}
 99
100#[derive(Template)]
101#[template(path = "kzg10_groth16_decider_verifier.askama.sol", ext = "sol")]
102pub struct Groth16KZG10DeciderVerifier {
103    pub groth16_verifier: Groth16Verifier,
104    pub kzg10_verifier: KZG10Verifier,
105}
106
107impl Deref for Groth16KZG10DeciderVerifier {
108    type Target = Groth16Verifier;
109
110    fn deref(&self) -> &Self::Target {
111        &self.groth16_verifier
112    }
113}