mock_verifier_inputs.cpp

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 }
// =====================
 
#include "mock_verifier_inputs.hpp"
#include "barretenberg/flavor/flavor.hpp"
#include "barretenberg/flavor/multilinear_batching_flavor.hpp"
#include "barretenberg/flavor/ultra_recursive_flavor.hpp"
#include "barretenberg/flavor/ultra_rollup_recursive_flavor.hpp"
#include "barretenberg/stdlib/honk_verifier/ultra_recursive_verifier.hpp"
#include "barretenberg/stdlib/primitives/bigfield/constants.hpp"
#include "barretenberg/stdlib/primitives/curves/bn254.hpp"
#include "barretenberg/stdlib/primitives/pairing_points.hpp"
#include "barretenberg/stdlib/special_public_inputs/special_public_inputs.hpp"
#include "proof_surgeon.hpp"
#include "recursion_constraint.hpp"
 
namespace acir_format {
 
using namespace bb;
 
template <class Curve = curve::BN254>
void populate_field_elements_for_mock_commitments(std::vector<fr>& fields, const size_t& num_commitments)
{
    auto mock_commitment = Curve::AffineElement::one();
    std::vector<fr> mock_commitment_frs = FrCodec::serialize_to_fields(mock_commitment);
    for (size_t i = 0; i < num_commitments; ++i) {
        for (const fr& val : mock_commitment_frs) {
            fields.emplace_back(val);
        }
    }
}
 
template <class FF = curve::BN254::ScalarField>
void populate_field_elements(std::vector<fr>& fields,
                             const size_t& num_elements,
                             std::optional<FF> value = std::nullopt)
{
    for (size_t i = 0; i < num_elements; ++i) {
        std::vector<fr> field_elements = value.has_value() ? FrCodec::serialize_to_fields(value.value())
                                                           : FrCodec::serialize_to_fields(FF::random_element());
        fields.insert(fields.end(), field_elements.begin(), field_elements.end());
    }
}
 
template <typename Flavor, class PublicInputs> HonkProof create_mock_oink_proof(const size_t inner_public_inputs_size)
{
    HonkProof proof;
 
    // Populate mock public inputs
    typename PublicInputs::Builder builder;
    PublicInputs::add_default(builder);
 
    // Populate the proof with as many public inputs as required from the ACIR constraints
    populate_field_elements<fr>(proof, inner_public_inputs_size);
 
    // Populate the proof with the public inputs added from barretenberg
    for (const auto& pub : builder.public_inputs()) {
        proof.emplace_back(builder.get_variable(pub));
    }
 
    // Populate mock witness polynomial commitments
    populate_field_elements_for_mock_commitments(proof, Flavor::NUM_WITNESS_ENTITIES);
 
    return proof;
}
 
template <typename Flavor> HonkProof create_mock_sumcheck_proof()
{
    using FF = typename Flavor::FF;
    HonkProof proof;
 
    // Sumcheck univariates
    const size_t TOTAL_SIZE_SUMCHECK_UNIVARIATES = Flavor::VIRTUAL_LOG_N * Flavor::BATCHED_RELATION_PARTIAL_LENGTH;
    populate_field_elements<FF>(proof, TOTAL_SIZE_SUMCHECK_UNIVARIATES);
 
    // Sumcheck multilinear evaluations
    populate_field_elements<FF>(proof, Flavor::NUM_ALL_ENTITIES);
 
    return proof;
}
 
HonkProof create_mock_multilinear_batch_proof()
{
    using Flavor = MultilinearBatchingFlavor;
    using FF = typename Flavor::FF;
    HonkProof proof;
 
    // Populate mock witness accumulator commitments
    populate_field_elements_for_mock_commitments(proof, Flavor::NUM_WITNESS_ENTITIES / 2);
 
    // Accumulator multivariate challenges
    populate_field_elements<FF>(proof, Flavor::VIRTUAL_LOG_N);
 
    // Witness accumulator polynomial evaluations
    populate_field_elements<FF>(proof, Flavor::NUM_WITNESS_ENTITIES / 2);
 
    // Sumcheck proof
    HonkProof sumcheck_proof = create_mock_sumcheck_proof<Flavor>();
 
    proof.insert(proof.end(), sumcheck_proof.begin(), sumcheck_proof.end());
 
    return proof;
}
 
template <typename Flavor, class PublicInputs> HonkProof create_mock_hyper_nova_proof(bool include_fold)
{
    HonkProof oink_proof = create_mock_oink_proof<Flavor, PublicInputs>(/*inner_public_inputs_size=*/0);
    HonkProof sumcheck_proof = create_mock_sumcheck_proof<Flavor>();
    HonkProof multilinear_batch_proof;
    if (include_fold) {
        multilinear_batch_proof = create_mock_multilinear_batch_proof();
    }
    HonkProof proof;
    proof.reserve(oink_proof.size() + sumcheck_proof.size() + multilinear_batch_proof.size());
    proof.insert(proof.end(), oink_proof.begin(), oink_proof.end());
    proof.insert(proof.end(), sumcheck_proof.begin(), sumcheck_proof.end());
    proof.insert(proof.end(), multilinear_batch_proof.begin(), multilinear_batch_proof.end());
 
    return proof;
}
 
// WORKTODO: use these methods in places where this logic is duplicated
template <typename Flavor> HonkProof create_mock_pcs_proof()
{
    using FF = Flavor::FF;
    using Curve = Flavor::Curve;
    HonkProof proof;
 
    // Gemini fold commitments
    const size_t NUM_GEMINI_FOLD_COMMITMENTS = Flavor::VIRTUAL_LOG_N - 1;
    populate_field_elements_for_mock_commitments<Curve>(proof, NUM_GEMINI_FOLD_COMMITMENTS);
 
    // Gemini fold evaluations
    const size_t NUM_GEMINI_FOLD_EVALUATIONS = Flavor::VIRTUAL_LOG_N;
    populate_field_elements<FF>(proof, NUM_GEMINI_FOLD_EVALUATIONS);
 
    if constexpr (std::is_same_v<Flavor, TranslatorFlavor>) {
        // Gemini P pos evaluation
        populate_field_elements<FF>(proof, 1);
 
        // Gemini P neg evaluation
        populate_field_elements<FF>(proof, 1);
    }
 
    if constexpr (Flavor::HasZK) {
        // NUM_SMALL_IPA_EVALUATIONS libra evals
        populate_field_elements<FF>(proof, NUM_SMALL_IPA_EVALUATIONS);
    }
 
    // Shplonk batched quotient commitment
    populate_field_elements_for_mock_commitments<Curve>(proof, /*num_commitments=*/1);
    // KZG quotient commitment
    populate_field_elements_for_mock_commitments<Curve>(proof, /*num_commitments=*/1);
 
    return proof;
}
 
template <typename Flavor> HonkProof create_mock_decider_proof()
{
    using FF = Flavor::FF;
    using Curve = Flavor::Curve;
    HonkProof proof;
 
    constexpr size_t const_proof_log_n = Flavor::VIRTUAL_LOG_N;
 
    if constexpr (Flavor::HasZK) {
        // Libra concatenation commitment
        populate_field_elements_for_mock_commitments<Curve>(proof, 1);
 
        // Libra sum
        populate_field_elements<FF>(proof, 1);
    }
 
    // Sumcheck univariates
    const size_t TOTAL_SIZE_SUMCHECK_UNIVARIATES = const_proof_log_n * Flavor::BATCHED_RELATION_PARTIAL_LENGTH;
    populate_field_elements<FF>(proof, TOTAL_SIZE_SUMCHECK_UNIVARIATES);
 
    // Sumcheck multilinear evaluations
    populate_field_elements<FF>(proof, Flavor::NUM_ALL_ENTITIES);
 
    if constexpr (Flavor::HasZK) {
        // Libra claimed evaluation
        populate_field_elements<FF>(proof, 1);
 
        // Libra grand sum commitment
        populate_field_elements_for_mock_commitments<Curve>(proof, 1);
 
        // Libra quotient commitment
        populate_field_elements_for_mock_commitments<Curve>(proof, 1);
    }
 
    // Gemini fold commitments
    const size_t NUM_GEMINI_FOLD_COMMITMENTS = const_proof_log_n - 1;
    populate_field_elements_for_mock_commitments<Curve>(proof, NUM_GEMINI_FOLD_COMMITMENTS);
 
    // Gemini fold evaluations
    const size_t NUM_GEMINI_FOLD_EVALUATIONS = const_proof_log_n;
    populate_field_elements<FF>(proof, NUM_GEMINI_FOLD_EVALUATIONS);
 
    if constexpr (std::is_same_v<Flavor, TranslatorFlavor>) {
        // Gemini P pos evaluation
        populate_field_elements<FF>(proof, 1);
 
        // Gemini P neg evaluation
        populate_field_elements<FF>(proof, 1);
    }
 
    if constexpr (Flavor::HasZK) {
        // NUM_SMALL_IPA_EVALUATIONS libra evals
        populate_field_elements<FF>(proof, NUM_SMALL_IPA_EVALUATIONS);
    }
 
    // Shplonk batched quotient commitment
    populate_field_elements_for_mock_commitments<Curve>(proof, /*num_commitments=*/1);
    // KZG quotient commitment
    populate_field_elements_for_mock_commitments<Curve>(proof, /*num_commitments=*/1);
 
    return proof;
}
 
template <typename Flavor, class PublicInputs> HonkProof create_mock_honk_proof(const size_t inner_public_inputs_size)
{
    // Construct a Honk proof as the concatenation of an Oink proof and a Decider proof
    HonkProof oink_proof = create_mock_oink_proof<Flavor, PublicInputs>(inner_public_inputs_size);
    HonkProof decider_proof = create_mock_decider_proof<Flavor>();
    HonkProof proof;
    proof.reserve(oink_proof.size() + decider_proof.size());
    proof.insert(proof.end(), oink_proof.begin(), oink_proof.end());
    proof.insert(proof.end(), decider_proof.begin(), decider_proof.end());
 
    if constexpr (HasIPAAccumulator<Flavor>) {
        HonkProof ipa_proof = create_mock_ipa_proof();
        proof.insert(proof.end(), ipa_proof.begin(), ipa_proof.end());
    }
    return proof;
}
 
template <typename Flavor>
std::pair<HonkProof, std::shared_ptr<typename Flavor::VerificationKey>> construct_honk_proof_for_simple_circuit(
    size_t num_inner_public_inputs)
{
    using ProverInstance = ProverInstance_<Flavor>;
    using InnerProver = bb::UltraProver_<Flavor>;
    using VerificationKey = Flavor::VerificationKey;
    using Builder = typename Flavor::CircuitBuilder;
 
    // constuct a circuit with a single gate
    Builder builder;
 
    fr a = fr::random_element();
    uint32_t a_idx = builder.add_variable(a);
 
    // have a big add gate added
    fr b = fr::random_element();
    fr c = fr::random_element();
    fr d = a + b + c;
    uint32_t b_idx = builder.add_variable(b);
    uint32_t c_idx = builder.add_variable(c);
    uint32_t d_idx = builder.add_variable(d);
 
    builder.create_big_add_gate({ a_idx, b_idx, c_idx, d_idx, fr(1), fr(1), fr(1), fr(-1), fr(0) });
 
    // Add the public inputs
    for (size_t i = 0; i < num_inner_public_inputs; ++i) {
        builder.add_public_variable(fr::random_element());
    }
 
    // Add the default pairing points and IPA claim
    if constexpr (HasIPAAccumulator<Flavor>) {
        stdlib::recursion::honk::RollupIO::add_default(builder);
    } else {
        stdlib::recursion::honk::DefaultIO<Builder>::add_default(builder);
    }
 
    // prove the circuit constructed above
    // Create the decider proving key
    auto decider_pk = std::make_shared<ProverInstance>(builder);
 
    // Construct the Ultra VK
    auto vk = std::make_shared<VerificationKey>(decider_pk->get_precomputed());
    InnerProver prover(decider_pk, vk);
    auto honk_proof = prover.construct_proof();
    return std::pair(honk_proof, vk);
}
 
Goblin::MergeProof create_mock_merge_proof()
{
    Goblin::MergeProof proof;
    proof.reserve(MERGE_PROOF_SIZE);
 
    uint32_t mock_shift_size = 5; // Must be smaller than 32, otherwise pow raises an error
 
    // Populate mock shift size
    populate_field_elements<fr>(proof, 1, /*value=*/fr{ mock_shift_size });
 
    // Populate mock merged table commitments and batched degree check polynomial commitment
    populate_field_elements_for_mock_commitments(proof, 5);
 
    // Populate evaluations (3 * NUM_WIRES + 1: left, right, and merged tables, plus batched degree check polynomial)
    populate_field_elements(proof, 13);
 
    // Shplonk proof: commitment to the quotient
    populate_field_elements_for_mock_commitments(proof, 1);
 
    // KZG proof: commitment to W
    populate_field_elements_for_mock_commitments(proof, 1);
 
    BB_ASSERT_EQ(proof.size(), MERGE_PROOF_SIZE);
 
    return proof;
}
 
template <typename Builder> HonkProof create_mock_chonk_proof(const size_t inner_public_inputs_size)
{
    HonkProof proof;
 
    HonkProof mega_proof = create_mock_honk_proof<MegaZKFlavor, stdlib::recursion::honk::HidingKernelIO<Builder>>(
        inner_public_inputs_size);
    Goblin::MergeProof merge_proof = create_mock_merge_proof();
    HonkProof eccvm_proof{ create_mock_eccvm_proof() };
    HonkProof ipa_proof = create_mock_ipa_proof();
    HonkProof translator_proof = create_mock_translator_proof();
 
    Chonk::Proof chonk_proof{ mega_proof, { merge_proof, eccvm_proof, ipa_proof, translator_proof } };
    proof = chonk_proof.to_field_elements();
 
    return proof;
}
 
HonkProof create_mock_eccvm_proof()
{
    using FF = ECCVMFlavor::FF;
    HonkProof proof;
 
    // 1. NUM_WITNESS_ENTITIES + 1 commitments (includes gemini_masking_poly)
    populate_field_elements_for_mock_commitments<curve::Grumpkin>(proof, ECCVMFlavor::NUM_WITNESS_ENTITIES + 1);
 
    // 2. Libra concatenation commitment
    populate_field_elements_for_mock_commitments<curve::Grumpkin>(proof, /*num_commitments*/ 1);
 
    // 3. Libra sum
    populate_field_elements<FF>(proof, 1);
 
    // 4. Sumcheck univariates commitments + 5. Sumcheck univariate evaluations
    for (size_t idx = 0; idx < CONST_ECCVM_LOG_N; idx++) {
        populate_field_elements_for_mock_commitments<curve::Grumpkin>(proof, /*num_commitments=*/1);
        populate_field_elements<FF>(proof, /*num_elements=*/2);
    }
 
    // 6. ALL_ENTITIES sumcheck evaluations
    populate_field_elements<FF>(proof, ECCVMFlavor::NUM_ALL_ENTITIES);
 
    // 7. Libra evaluation
    populate_field_elements<FF>(proof, 1);
 
    // 8. Libra grand sum commitment
    populate_field_elements_for_mock_commitments<curve::Grumpkin>(proof, /*num_commitments=*/1);
 
    // 9. Libra quotient commitment
    populate_field_elements_for_mock_commitments<curve::Grumpkin>(proof, /*num_commitments=*/1);
 
    // 10. Gemini fold commitments
    populate_field_elements_for_mock_commitments<curve::Grumpkin>(proof,
                                                                  /*num_commitments=*/CONST_ECCVM_LOG_N - 1);
 
    // 11. Gemini evaluations
    populate_field_elements<FF>(proof, CONST_ECCVM_LOG_N);
 
    // 12. NUM_SMALL_IPA_EVALUATIONS libra evals
    populate_field_elements<FF>(proof, NUM_SMALL_IPA_EVALUATIONS);
 
    // 13. Shplonk
    populate_field_elements_for_mock_commitments<curve::Grumpkin>(proof, /*num_commitments=*/1);
 
    // 14. Translator concatenated masking term commitment
    populate_field_elements_for_mock_commitments<curve::Grumpkin>(proof, /*num_commitments=*/1);
 
    // 15. Translator op evaluation
    populate_field_elements<FF>(proof, 1);
 
    // 16. Translator Px evaluation
    populate_field_elements<FF>(proof, 1);
 
    // 17. Translator Py evaluation
    populate_field_elements<FF>(proof, 1);
 
    // 18. Translator z1 evaluation
    populate_field_elements<FF>(proof, 1);
 
    // 19. Translator z2 evaluation
    populate_field_elements<FF>(proof, 1);
 
    // 20. Translator concatenated masking term evaluation
    populate_field_elements<FF>(proof, 1);
 
    // 21. Translator grand sum commitment
    populate_field_elements_for_mock_commitments<curve::Grumpkin>(proof, /*num_commitments=*/1);
 
    // 22. Translator quotient commitment
    populate_field_elements_for_mock_commitments<curve::Grumpkin>(proof, /*num_commitments=*/1);
 
    // 23. Translator concatenation evaluation
    populate_field_elements<FF>(proof, 1);
 
    // 24. Translator grand sum shift evaluation
    populate_field_elements<FF>(proof, 1);
 
    // 25. Translator grand sum evaluation
    populate_field_elements<FF>(proof, 1);
 
    // 26. Translator quotient evaluation
    populate_field_elements<FF>(proof, 1);
 
    // 27. Shplonk
    populate_field_elements_for_mock_commitments<curve::Grumpkin>(proof, /*num_commitments=*/1);
 
    BB_ASSERT_EQ(proof.size(), ECCVMFlavor::PROOF_LENGTH_WITHOUT_PUB_INPUTS);
 
    return proof;
}
 
HonkProof create_mock_ipa_proof()
{
    HonkProof proof;
 
    // Commitments to L and R for CONST_ECCVM_LOG_N round
    populate_field_elements_for_mock_commitments<curve::Grumpkin>(
        proof, /*num_commitments=*/CONST_ECCVM_LOG_N + CONST_ECCVM_LOG_N);
 
    // Commitment to G_0
    populate_field_elements_for_mock_commitments<curve::Grumpkin>(proof, /*num_commitments=*/1);
 
    // a_0 evaluation (a_0 is in the base field of BN254)
    populate_field_elements<curve::BN254::BaseField>(proof, 1);
 
    BB_ASSERT_EQ(proof.size(), IPA_PROOF_LENGTH);
 
    return proof;
}
 
HonkProof create_mock_translator_proof()
{
    using Curve = TranslatorFlavor::Curve;
 
    HonkProof proof;
 
    // 1. NUM_WITNESS_ENTITIES commitments (includes gemini masking, wires, ordered range constraints, z_perm; excludes
    // 2 interleaved)
    populate_field_elements_for_mock_commitments<Curve>(proof,
                                                        /*num_commitments=*/TranslatorFlavor::NUM_WITNESS_ENTITIES - 3 -
                                                            TranslatorFlavor::NUM_OP_QUEUE_WIRES);
 
    // 3. Decider proof (Libra + sumcheck + Gemini + PCS)
    HonkProof decider_proof = create_mock_decider_proof<TranslatorFlavor>();
    proof.insert(proof.end(), decider_proof.begin(), decider_proof.end());
 
    BB_ASSERT_EQ(proof.size(), TranslatorFlavor::PROOF_LENGTH_WITHOUT_PUB_INPUTS);
 
    return proof;
}
 
template <typename Flavor, class PublicInputs>
std::shared_ptr<typename Flavor::VerificationKey> create_mock_honk_vk(const size_t dyadic_size,
                                                                      const size_t pub_inputs_offset,
                                                                      const size_t inner_public_inputs_size)
{
    // Set relevant VK metadata and commitments
    auto honk_verification_key = std::make_shared<typename Flavor::VerificationKey>();
    honk_verification_key->log_circuit_size = bb::numeric::get_msb(dyadic_size);
    honk_verification_key->num_public_inputs = inner_public_inputs_size + PublicInputs::PUBLIC_INPUTS_SIZE;
    honk_verification_key->pub_inputs_offset = pub_inputs_offset; // must be set correctly
 
    for (auto& commitment : honk_verification_key->get_all()) {
        commitment = curve::BN254::AffineElement::one(); // arbitrary mock commitment
    }
 
    return honk_verification_key;
}
 
template <typename Flavor> std::shared_ptr<VerifierInstance_<Flavor>> create_mock_verifier_instance()
{
    using FF = typename Flavor::FF;
 
    // Set relevant VK metadata and commitments
    auto verifier_instance = std::make_shared<VerifierInstance_<Flavor>>();
    std::shared_ptr<typename Flavor::VerificationKey> vk =
        create_mock_honk_vk<Flavor, stdlib::recursion::honk::DefaultIO<typename Flavor::CircuitBuilder>>(
            0, 0); // metadata does not need to be accurate
    verifier_instance->vk = vk;
    verifier_instance->is_complete = true;
    verifier_instance->gate_challenges =
        std::vector<FF>(static_cast<size_t>(CONST_FOLDING_LOG_N), FF::random_element());
 
    for (auto& commitment : verifier_instance->witness_commitments.get_all()) {
        commitment = curve::BN254::AffineElement::one(); // arbitrary mock commitment
    }
 
    return verifier_instance;
}
 
// Explicitly instantiate template functions
template HonkProof create_mock_oink_proof<MegaFlavor, stdlib::recursion::honk::AppIO>(const size_t);
template HonkProof create_mock_oink_proof<MegaFlavor, stdlib::recursion::honk::KernelIO>(const size_t);
template HonkProof create_mock_oink_proof<MegaFlavor, stdlib::recursion::honk::HidingKernelIO<MegaCircuitBuilder>>(
    const size_t);
 
template HonkProof create_mock_oink_proof<UltraFlavor, stdlib::recursion::honk::DefaultIO<UltraCircuitBuilder>>(
    const size_t);
template HonkProof create_mock_oink_proof<UltraZKFlavor, stdlib::recursion::honk::DefaultIO<UltraCircuitBuilder>>(
    const size_t);
template HonkProof create_mock_oink_proof<UltraFlavor, stdlib::recursion::honk::DefaultIO<MegaCircuitBuilder>>(
    const size_t);
template HonkProof create_mock_oink_proof<UltraZKFlavor, stdlib::recursion::honk::DefaultIO<MegaCircuitBuilder>>(
    const size_t);
template HonkProof create_mock_oink_proof<UltraRollupFlavor, stdlib::recursion::honk::RollupIO>(const size_t);
 
template HonkProof create_mock_pcs_proof<MegaFlavor>();
 
template HonkProof create_mock_decider_proof<MegaFlavor>();
template HonkProof create_mock_decider_proof<UltraFlavor>();
template HonkProof create_mock_decider_proof<UltraZKFlavor>();
template HonkProof create_mock_decider_proof<UltraRollupFlavor>();
template HonkProof create_mock_decider_proof<TranslatorFlavor>();
 
template HonkProof create_mock_honk_proof<MegaFlavor, stdlib::recursion::honk::AppIO>(const size_t);
template HonkProof create_mock_honk_proof<MegaFlavor, stdlib::recursion::honk::KernelIO>(const size_t);
template HonkProof create_mock_honk_proof<MegaFlavor, stdlib::recursion::honk::HidingKernelIO<MegaCircuitBuilder>>(
    const size_t);
 
template HonkProof create_mock_honk_proof<UltraFlavor, stdlib::recursion::honk::DefaultIO<UltraCircuitBuilder>>(
    const size_t);
template HonkProof create_mock_honk_proof<UltraZKFlavor, stdlib::recursion::honk::DefaultIO<UltraCircuitBuilder>>(
    const size_t);
template HonkProof create_mock_honk_proof<UltraFlavor, stdlib::recursion::honk::DefaultIO<MegaCircuitBuilder>>(
    const size_t);
template HonkProof create_mock_honk_proof<UltraZKFlavor, stdlib::recursion::honk::DefaultIO<MegaCircuitBuilder>>(
    const size_t);
template HonkProof create_mock_honk_proof<UltraRollupFlavor, stdlib::recursion::honk::RollupIO>(const size_t);
 
template std::pair<HonkProof, std::shared_ptr<UltraFlavor::VerificationKey>> construct_honk_proof_for_simple_circuit<
    UltraFlavor>(size_t num_public_inputs);
template std::pair<HonkProof, std::shared_ptr<UltraZKFlavor::VerificationKey>> construct_honk_proof_for_simple_circuit<
    UltraZKFlavor>(size_t num_public_inputs);
template std::pair<HonkProof, std::shared_ptr<UltraRollupFlavor::VerificationKey>>
construct_honk_proof_for_simple_circuit<UltraRollupFlavor>(size_t num_public_inputs);
 
// template HonkProof create_mock_pg_proof<MegaFlavor, stdlib::recursion::honk::AppIO>();
// template HonkProof create_mock_pg_proof<MegaFlavor, stdlib::recursion::honk::KernelIO>();
// template HonkProof create_mock_pg_proof<MegaFlavor, stdlib::recursion::honk::HidingKernelIO<MegaCircuitBuilder>>();
 
template HonkProof create_mock_hyper_nova_proof<MegaFlavor, stdlib::recursion::honk::DefaultIO<MegaCircuitBuilder>>(
    bool);
template HonkProof create_mock_hyper_nova_proof<MegaFlavor, stdlib::recursion::honk::KernelIO>(bool);
 
template HonkProof create_mock_chonk_proof<UltraCircuitBuilder>(const size_t);
template HonkProof create_mock_chonk_proof<MegaCircuitBuilder>(const size_t);
 
template std::shared_ptr<MegaFlavor::VerificationKey> create_mock_honk_vk<MegaFlavor, stdlib::recursion::honk::AppIO>(
    const size_t, const size_t, const size_t);
template std::shared_ptr<MegaFlavor::VerificationKey> create_mock_honk_vk<MegaFlavor,
                                                                          stdlib::recursion::honk::KernelIO>(
    const size_t, const size_t, const size_t);
template std::shared_ptr<MegaFlavor::VerificationKey> create_mock_honk_vk<
    MegaFlavor,
    stdlib::recursion::honk::HidingKernelIO<MegaCircuitBuilder>>(const size_t, const size_t, const size_t);
template std::shared_ptr<MegaZKFlavor::VerificationKey> create_mock_honk_vk<
    MegaZKFlavor,
    stdlib::recursion::honk::HidingKernelIO<UltraCircuitBuilder>>(const size_t, const size_t, const size_t);
 
template std::shared_ptr<UltraFlavor::VerificationKey> create_mock_honk_vk<
    UltraFlavor,
    stdlib::recursion::honk::DefaultIO<UltraCircuitBuilder>>(const size_t, const size_t, const size_t);
template std::shared_ptr<UltraZKFlavor::VerificationKey> create_mock_honk_vk<
    UltraZKFlavor,
    stdlib::recursion::honk::DefaultIO<UltraCircuitBuilder>>(const size_t, const size_t, const size_t);
template std::shared_ptr<UltraFlavor::VerificationKey> create_mock_honk_vk<
    UltraFlavor,
    stdlib::recursion::honk::DefaultIO<MegaCircuitBuilder>>(const size_t, const size_t, const size_t);
template std::shared_ptr<UltraZKFlavor::VerificationKey> create_mock_honk_vk<
    UltraZKFlavor,
    stdlib::recursion::honk::DefaultIO<MegaCircuitBuilder>>(const size_t, const size_t, const size_t);
template std::shared_ptr<UltraRollupFlavor::VerificationKey> create_mock_honk_vk<UltraRollupFlavor,
                                                                                 stdlib::recursion::honk::RollupIO>(
    const size_t, const size_t, const size_t);
 
template std::shared_ptr<VerifierInstance_<MegaFlavor>> create_mock_verifier_instance<MegaFlavor>();
 
} // namespace acir_format