Method _verify

proof_system/src/verifier.rs:144–1836

(
        self,
        rng: &mut R,
        proof_spec: ProofSpec<E>,
        nonce: Option<Vec<u8>>,
        mut pairing_checker: Option<RandomizedPairingChecker<E>>,
    )

    }

    fn _verify<R: RngCore, D: FullDigest + Digest>(
        self,
        rng: &mut R,
        proof_spec: ProofSpec<E>,
        nonce: Option<Vec<u8>>,
        mut pairing_checker: Option<RandomizedPairingChecker<E>>,
    ) -> Result<(), ProofSystemError> {
        proof_spec.validate()?;

        // Number of statement proofs is less than number of statements which means some statements
        // are not satisfied.
        if proof_spec.statements.len() > self.statement_proofs.len() {
            return Err(ProofSystemError::UnsatisfiedStatements(
                proof_spec.statements.len(),
                self.statement_proofs.len(),
            ));
        }

        let mut transcript = MerlinTranscript::new(COMPOSITE_PROOF_LABEL);

        // TODO: Check SNARK SRSs compatible when aggregating and statement proof compatible with proof spec when aggregating

        let aggregate_snarks =
            proof_spec.aggregate_groth16.is_some() || proof_spec.aggregate_legogroth16.is_some();
        let mut agg_saver = Vec::<Vec<Ciphertext<E>>>::new();
        let mut agg_lego = Vec::<(Vec<E::G1Affine>, Vec<Vec<E::ScalarField>>)>::new();

        let mut agg_saver_stmts = BTreeMap::new();
        let mut agg_lego_stmts = BTreeMap::new();

        if aggregate_snarks {
            if let Some(a) = &proof_spec.aggregate_groth16 {
                for (i, s) in a.iter().enumerate() {
                    for j in s {
                        agg_saver_stmts.insert(*j, i);
                    }
                    agg_saver.push(vec![]);
                }
            }

            if let Some(a) = &proof_spec.aggregate_legogroth16 {
                for (i, s) in a.iter().enumerate() {
                    for j in s {
                        agg_lego_stmts.insert(*j, i);
                    }
                    agg_lego.push((vec![], vec![]));
                }
            }
        }

        // Prepare commitment keys for running Schnorr protocols of all statements.
        let (
            bound_check_comm,
            ek_comm,
            chunked_comm,
            r1cs_comm_keys,
            bound_check_bpp_comm,
            bound_check_smc_comm,