protogalaxy_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/flavor.hpp"
#include "barretenberg/flavor/mega_recursive_flavor.hpp"
#include "barretenberg/honk/proof_system/types/proof.hpp"
#include "barretenberg/protogalaxy/folding_result.hpp"
#include "barretenberg/stdlib/proof/proof.hpp"
#include "barretenberg/stdlib/protogalaxy_verifier/recursive_decider_verification_keys.hpp"
#include "barretenberg/stdlib/transcript/transcript.hpp"
#include "barretenberg/ultra_honk/decider_keys.hpp"
 
namespace bb::stdlib::recursion::honk {
template <class DeciderVerificationKeys> class ProtogalaxyRecursiveVerifier_ {
  public:
    using Flavor = typename DeciderVerificationKeys::Flavor;
    using FF = typename Flavor::FF;
    using Commitment = typename Flavor::Commitment;
    using DeciderVK = typename DeciderVerificationKeys::DeciderVK;
    using VKAndHash = typename Flavor::VKAndHash;
 
    using Builder = typename Flavor::CircuitBuilder;
    using Transcript = bb::BaseTranscript<bb::stdlib::recursion::honk::StdlibTranscriptParams<Builder>>;
 
    static constexpr size_t NUM_SUBRELATIONS = Flavor::NUM_SUBRELATIONS;
 
    Builder* builder;
 
    DeciderVerificationKeys keys_to_fold;
 
    std::shared_ptr<Transcript> transcript = std::make_shared<Transcript>();
 
    ProtogalaxyRecursiveVerifier_(Builder* builder,
                                  const std::shared_ptr<DeciderVK>& accumulator,
                                  const std::vector<std::shared_ptr<VKAndHash>>& vk_and_hashs,
                                  const std::shared_ptr<Transcript>& transcript)
        : builder(builder)
        , keys_to_fold(DeciderVerificationKeys(builder, accumulator, vk_and_hashs))
        , transcript(transcript) {};
 
    ProtogalaxyRecursiveVerifier_(Builder* builder,
                                  const std::shared_ptr<DeciderVK>& accumulator,
                                  const std::shared_ptr<DeciderVK>& incoming_instance,
                                  const std::shared_ptr<Transcript>& transcript)
        : builder(builder)
        , keys_to_fold(DeciderVerificationKeys(builder, accumulator, incoming_instance))
        , transcript(transcript) {};
 
    void run_oink_verifier_on_each_incomplete_key(const std::vector<FF>&);
 
    std::shared_ptr<DeciderVK> verify_folding_proof(const stdlib::Proof<Builder>&);
};
 
} // namespace bb::stdlib::recursion::honk