recursive_verifier_instance.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/commitment_schemes/verification_key.hpp"
#include "barretenberg/flavor/flavor.hpp"
#include "barretenberg/relations/relation_parameters.hpp"
#include "barretenberg/ultra_honk/verifier_instance.hpp"
 
namespace bb::stdlib::recursion::honk {
 
template <IsRecursiveFlavor Flavor_> class RecursiveVerifierInstance_ {
  public:
    using Flavor = Flavor_;
    using FF = typename Flavor::FF;
    using NativeFF = typename Flavor::Curve::ScalarFieldNative;
    using Commitment = typename Flavor::Commitment;
    using VerificationKey = typename Flavor::VerificationKey;
    using VKAndHash = typename Flavor::VKAndHash;
    using WitnessCommitments = typename Flavor::WitnessCommitments;
    using CommitmentLabels = typename Flavor::CommitmentLabels;
    using SubrelationSeparator = typename Flavor::SubrelationSeparator;
    using Builder = typename Flavor::CircuitBuilder;
    using NativeFlavor = typename Flavor::NativeFlavor;
    using NativeVerificationKey = typename Flavor::NativeFlavor::VerificationKey;
    using NativeVerifierInstance = bb::VerifierInstance_<NativeFlavor>;
    using VerifierCommitmentKey = typename NativeFlavor::VerifierCommitmentKey;
    using Transcript = typename Flavor::Transcript;
 
    Builder* builder;
 
    std::shared_ptr<VKAndHash> vk_and_hash;
 
    bool is_complete = false;      // whether this instance has been completely populated
    std::vector<FF> public_inputs; // to be extracted from the corresponding proof
 
    // Single alpha challenge from which powers are computed for batching subrelations
    SubrelationSeparator alpha;
    RelationParameters<FF> relation_parameters;
    std::vector<FF> gate_challenges;
 
    WitnessCommitments witness_commitments;
    CommitmentLabels commitment_labels;
 
    // For ZK flavors: commitment to Gemini masking polynomial
    Commitment gemini_masking_commitment;
 
    RecursiveVerifierInstance_(Builder* builder)
        : builder(builder) {};
 
    // Constructor from native vk
    RecursiveVerifierInstance_(Builder* builder, std::shared_ptr<NativeVerificationKey> vk)
        : builder(builder)
        , vk_and_hash(std::make_shared<VKAndHash>(std::make_shared<VerificationKey>(builder, vk),
                                                  FF::from_witness(builder, vk->hash())))
    {}
 
    // Constructor from stdlib vk and hash
    RecursiveVerifierInstance_(Builder* builder, std::shared_ptr<VKAndHash> vk_and_hash)
        : builder(builder)
        , vk_and_hash(vk_and_hash) {};
 
    std::shared_ptr<VerificationKey> get_vk() const { return vk_and_hash->vk; }
 
    // Constructor from native verifier instance
    RecursiveVerifierInstance_(Builder* builder, std::shared_ptr<NativeVerifierInstance> verification_key)
        : RecursiveVerifierInstance_(builder, verification_key->vk)
    {
        is_complete = verification_key->is_complete;
        if (is_complete) {
            alpha = FF::from_witness(builder, verification_key->alpha);
 
            auto other_comms = verification_key->witness_commitments.get_all();
            size_t comm_idx = 0;
            for (auto& comm : witness_commitments.get_all()) {
                comm = Commitment::from_witness(builder, other_comms[comm_idx]);
                comm_idx++;
            }
            size_t challenge_idx = 0;
            gate_challenges = std::vector<FF>(verification_key->gate_challenges.size());
            for (auto& challenge : gate_challenges) {
                challenge = FF::from_witness(builder, verification_key->gate_challenges[challenge_idx]);
                challenge_idx++;
            }
            relation_parameters.eta = FF::from_witness(builder, verification_key->relation_parameters.eta);
            relation_parameters.eta_two = FF::from_witness(builder, verification_key->relation_parameters.eta_two);
            relation_parameters.eta_three = FF::from_witness(builder, verification_key->relation_parameters.eta_three);
            relation_parameters.beta = FF::from_witness(builder, verification_key->relation_parameters.beta);
            relation_parameters.gamma = FF::from_witness(builder, verification_key->relation_parameters.gamma);
            relation_parameters.public_input_delta =
                FF::from_witness(builder, verification_key->relation_parameters.public_input_delta);
 
            // For ZK flavors: convert gemini_masking_commitment
            if constexpr (NativeFlavor::HasZK) {
                gemini_masking_commitment =
                    Commitment::from_witness(builder, verification_key->gemini_masking_commitment);
            }
        }
    }
 
    NativeVerifierInstance get_value()
    {
        using NativeVerificationKey = typename Flavor::NativeFlavor::VerificationKey;
        auto native_honk_vk = std::make_shared<NativeVerificationKey>();
        native_honk_vk->log_circuit_size = static_cast<uint64_t>(vk_and_hash->vk->log_circuit_size.get_value());
        native_honk_vk->num_public_inputs = static_cast<uint64_t>(vk_and_hash->vk->num_public_inputs.get_value());
        native_honk_vk->pub_inputs_offset = static_cast<uint64_t>(vk_and_hash->vk->pub_inputs_offset.get_value());
 
        for (auto [vk, final_verifier_inst] : zip_view(vk_and_hash->vk->get_all(), native_honk_vk->get_all())) {
            final_verifier_inst = vk.get_value();
        }
 
        NativeVerifierInstance verifier_inst(native_honk_vk);
        verifier_inst.is_complete = is_complete;
 
        verifier_inst.alpha = alpha.get_value();
 
        for (auto [comm, inst_comm] :
             zip_view(witness_commitments.get_all(), verifier_inst.witness_commitments.get_all())) {
            inst_comm = comm.get_value();
        }
 
        verifier_inst.gate_challenges = std::vector<NativeFF>(gate_challenges.size());
        for (auto [challenge, inst_challenge] : zip_view(gate_challenges, verifier_inst.gate_challenges)) {
            inst_challenge = challenge.get_value();
        }
 
        verifier_inst.relation_parameters.eta = relation_parameters.eta.get_value();
        verifier_inst.relation_parameters.eta_two = relation_parameters.eta_two.get_value();
        verifier_inst.relation_parameters.eta_three = relation_parameters.eta_three.get_value();
        verifier_inst.relation_parameters.beta = relation_parameters.beta.get_value();
        verifier_inst.relation_parameters.gamma = relation_parameters.gamma.get_value();
        verifier_inst.relation_parameters.public_input_delta = relation_parameters.public_input_delta.get_value();
 
        // For ZK flavors: convert gemini_masking_commitment back to native
        if constexpr (NativeFlavor::HasZK) {
            verifier_inst.gemini_masking_commitment = gemini_masking_commitment.get_value();
        }
 
        return verifier_inst;
    }
};
} // namespace bb::stdlib::recursion::honk