decider_recursive_verifier.hpp

Go to the documentation of this file.

// === AUDIT STATUS ===
// internal:    { status: not started, auditors: [], date: YYYY-MM-DD }
// external_1:  { status: not started, auditors: [], date: YYYY-MM-DD }
// external_2:  { status: not started, auditors: [], date: YYYY-MM-DD }
// =====================
 
#pragma once
#include "barretenberg/flavor/mega_recursive_flavor.hpp"
#include "barretenberg/honk/proof_system/types/proof.hpp"
#include "barretenberg/stdlib/primitives/pairing_points.hpp"
#include "barretenberg/stdlib/proof/proof.hpp"
#include "barretenberg/stdlib/protogalaxy_verifier/recursive_verifier_instance.hpp"
#include "barretenberg/sumcheck/sumcheck.hpp"
#include "barretenberg/transcript/transcript.hpp"
 
namespace bb::stdlib::recursion::honk {
template <typename Flavor> class DeciderRecursiveVerifier_ {
    using NativeFlavor = typename Flavor::NativeFlavor;
    using FF = typename Flavor::FF;
    using Commitment = typename Flavor::Commitment;
    using GroupElement = typename Flavor::GroupElement;
    using VerificationKey = typename Flavor::VerificationKey;
    using VerifierCommitmentKey = typename Flavor::VerifierCommitmentKey;
    using Builder = typename Flavor::CircuitBuilder;
    using PairingPoints = stdlib::recursion::PairingPoints<Builder>;
    using RecursiveVerifierInstance = RecursiveVerifierInstance_<Flavor>;
    using NativeVerifierInstance = bb::VerifierInstance_<NativeFlavor>;
    using Transcript = StdlibTranscript<Builder>;
    using StdlibProof = bb::stdlib::Proof<Builder>;
 
  public:
    explicit DeciderRecursiveVerifier_(Builder* builder, std::shared_ptr<NativeVerifierInstance> accumulator)
        : builder(builder)
        , accumulator(std::make_shared<RecursiveVerifierInstance>(builder, accumulator)) {};
 
    explicit DeciderRecursiveVerifier_(Builder* builder,
                                       std::shared_ptr<RecursiveVerifierInstance> accumulator,
                                       const std::shared_ptr<Transcript>& transcript)
        : builder(builder)
        , transcript(transcript)
    {
        if (this->builder == accumulator->builder) {
            this->accumulator = std::move(accumulator);
        } else {
            this->accumulator = std::make_shared<RecursiveVerifierInstance>(
                this->builder, std::make_shared<NativeVerifierInstance>(accumulator->get_value()));
        }
    }
 
    [[nodiscard("Pairing points should be accumulated")]] PairingPoints verify_proof(const HonkProof& proof);
    [[nodiscard("Pairing points should be accumulated")]] PairingPoints verify_proof(const StdlibProof& proof);
 
    VerifierCommitmentKey pcs_verification_key;
    Builder* builder;
    std::shared_ptr<RecursiveVerifierInstance> accumulator;
    std::shared_ptr<Transcript> transcript = std::make_shared<Transcript>();
};
 
} // namespace bb::stdlib::recursion::honk