recursive_verifier.hpp

Go to the documentation of this file.

// === AUDIT STATUS ===
// internal:    { status: Planned, auditors: [Federico], commit: }
// external_1:  { status: not started, auditors: [], commit: }
// external_2:  { status: not started, auditors: [], commit: }
// =====================
 
#pragma once
 
#include "barretenberg/stdlib/primitives/pairing_points.hpp"
#include "barretenberg/stdlib/proof/proof.hpp"
#include "barretenberg/sumcheck/sumcheck.hpp"
#include "barretenberg/vm2/constraining/recursion/recursive_flavor.hpp"
 
namespace bb::avm2 {
 
class AvmRecursiveVerifier {
    using Flavor = AvmRecursiveFlavor;
    using FF = typename Flavor::FF;
    using BF = typename Flavor::BF;
    using Curve = typename Flavor::Curve;
    using Commitment = typename Flavor::Commitment;
    using SubrelationSeparators = typename Flavor::SubrelationSeparators;
    using VerificationKey = typename Flavor::VerificationKey;
    using NativeVerificationKey = typename Flavor::NativeVerificationKey;
    using Builder = typename Flavor::CircuitBuilder;
    using PCS = typename Flavor::PCS;
    using Transcript = StdlibTranscript<Builder>;
    using VerifierCommitments = typename Flavor::VerifierCommitments;
    using PairingPoints = stdlib::recursion::PairingPoints<Curve>;
    using StdlibProof = stdlib::Proof<Builder>;
 
  public:
    explicit AvmRecursiveVerifier(Builder& builder);
 
    [[nodiscard("IPA claim and Pairing points should be accumulated")]] PairingPoints verify_proof(
        const HonkProof& proof, const std::vector<std::vector<fr>>& public_inputs_vec_nt);
    [[nodiscard("IPA claim and Pairing points should be accumulated")]] PairingPoints verify_proof(
        const StdlibProof& stdlib_proof, const std::vector<std::vector<typename Flavor::FF>>& public_inputs);
 
    Builder& builder;
    std::shared_ptr<VerificationKey> key;
    FF vk_hash;
    std::shared_ptr<Transcript> transcript = std::make_shared<Transcript>();
 
  private:
    FF evaluate_public_input_column(const std::vector<FF>& points, const std::vector<FF>& challenges);
};
 
} // namespace bb::avm2