chonk_recursion_constraints.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 "barretenberg/dsl/acir_format/mock_verifier_inputs.hpp"
#include "barretenberg/dsl/acir_format/recursion_constraint.hpp"
#include "barretenberg/stdlib/chonk_verifier/chonk_recursive_verifier.hpp"
#include "barretenberg/stdlib/primitives/bigfield/bigfield.hpp"
#include "proof_surgeon.hpp"
 
namespace acir_format {
 
using namespace bb;
 
void create_dummy_vkey_and_proof(UltraCircuitBuilder& builder,
                                 size_t proof_size,
                                 size_t public_inputs_size,
                                 const std::vector<stdlib::field_t<UltraCircuitBuilder>>& key_fields,
                                 const std::vector<stdlib::field_t<UltraCircuitBuilder>>& proof_fields)
{
    using Builder = UltraCircuitBuilder;
    using ChonkRecursiveVerifier = stdlib::recursion::honk::ChonkRecursiveVerifier;
    using IO = stdlib::recursion::honk::HidingKernelIO<Builder>;
 
    BB_ASSERT_EQ(proof_size, ChonkRecursiveVerifier::StdlibProof::PROOF_LENGTH_WITHOUT_PUB_INPUTS());
 
    size_t num_inner_public_inputs = public_inputs_size - IO::PUBLIC_INPUTS_SIZE;
    uint32_t pub_inputs_offset = MegaZKFlavor::has_zero_row ? 1 : 0;
 
    // Generate mock honk vk
    // Note: log_circuit_size = VIRTUAL_LOG_N
    auto honk_vk = create_mock_honk_vk<MegaZKFlavor, IO>(
        1 << MegaZKFlavor::VIRTUAL_LOG_N, pub_inputs_offset, num_inner_public_inputs);
 
    // Set honk vk in builder
    size_t offset = 0;
    for (auto& vk_element : honk_vk->to_field_elements()) {
        builder.set_variable(key_fields[offset].get_witness_index(), vk_element);
        offset++;
    }
 
    // Generate dummy Chonk proof
    bb::HonkProof chonk_proof = create_mock_chonk_proof<Builder>(num_inner_public_inputs);
 
    // Set Chonk proof in builder
    offset = 0;
    for (auto& proof_element : chonk_proof) {
        builder.set_variable(proof_fields[offset].get_witness_index(), proof_element);
        offset++;
    }
 
    BB_ASSERT_EQ(offset, proof_size + public_inputs_size);
}
 
[[nodiscard(
    "IPA claim and Pairing points should be accumulated")]] HonkRecursionConstraintOutput<bb::UltraCircuitBuilder>
create_chonk_recursion_constraints(bb::UltraCircuitBuilder& builder, const RecursionConstraint& input)
{
    using Builder = bb::UltraCircuitBuilder;
    using field_ct = stdlib::field_t<Builder>;
    using ChonkRecursiveVerifier = stdlib::recursion::honk::ChonkRecursiveVerifier;
    using RecursiveVKAndHash = ChonkRecursiveVerifier::RecursiveVKAndHash;
    using VerificationKey = ChonkRecursiveVerifier::RecursiveVK;
    using IO = stdlib::recursion::honk::HidingKernelIO<Builder>;
 
    BB_ASSERT_EQ(input.proof_type, PROOF_TYPE::CHONK);
 
    // Reconstruct proof indices from proof and public inputs
    std::vector<uint32_t> proof_indices =
        ProofSurgeon<uint32_t>::create_indices_for_reconstructed_proof(input.proof, input.public_inputs);
 
    // Construct field elements from witness indices
    std::vector<field_ct> key_fields = RecursionConstraint::fields_from_witnesses(builder, input.key);
    std::vector<field_ct> proof_fields = RecursionConstraint::fields_from_witnesses(builder, proof_indices);
    field_ct vk_hash = field_ct::from_witness_index(&builder, input.key_hash);
 
    if (builder.is_write_vk_mode()) {
        size_t total_pub_inputs_size = input.public_inputs.size() + IO::PUBLIC_INPUTS_SIZE;
        size_t proof_size_without_pub_inputs = input.proof.size() - IO::PUBLIC_INPUTS_SIZE;
 
        create_dummy_vkey_and_proof(
            builder, proof_size_without_pub_inputs, total_pub_inputs_size, key_fields, proof_fields);
    }
 
    // Recursively verify Chonk proof
    auto mega_vk = std::make_shared<VerificationKey>(key_fields);
    auto mega_vk_and_hash = std::make_shared<RecursiveVKAndHash>(mega_vk, vk_hash);
    ChonkRecursiveVerifier::StdlibProof stdlib_proof(proof_fields, input.public_inputs.size());
 
    ChonkRecursiveVerifier verifier(&builder, mega_vk_and_hash);
    ChonkRecursiveVerifier::Output verification_output = verifier.verify(stdlib_proof);
 
    // Construct output
    HonkRecursionConstraintOutput<Builder> output;
    output.points_accumulator = verification_output.points_accumulator;
    output.ipa_claim = verification_output.opening_claim;
    output.ipa_proof = verification_output.ipa_proof;
 
    return output;
}
 
} // namespace acir_format