proof_surgeon.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/common/map.hpp"
#include "barretenberg/common/serialize.hpp"
#include "barretenberg/dsl/acir_format/utils.hpp"
#include "barretenberg/ecc/curves/bn254/fr.hpp"
#include "barretenberg/flavor/flavor.hpp"
#include "barretenberg/honk/proof_system/types/proof.hpp"
#include "barretenberg/serialize/msgpack.hpp"
#include "barretenberg/special_public_inputs/special_public_inputs.hpp"
#include "barretenberg/stdlib/proof/proof.hpp"
#include <barretenberg/common/container.hpp>
#include <cstdint>
 
namespace acir_format {
 
template <typename FF> class ProofSurgeon {
  public:
    static std::vector<uint32_t> create_indices_for_reconstructed_proof(const std::vector<uint32_t>& proof_in,
                                                                        const std::vector<uint32_t>& public_inputs)
    {
        std::vector<uint32_t> proof;
        proof.reserve(proof_in.size() + public_inputs.size());
 
        // Construct the complete proof as the concatenation {"initial data" | public_inputs | proof_in}
        proof.insert(proof.end(), public_inputs.begin(), public_inputs.end());
        proof.insert(proof.end(), proof_in.begin(), proof_in.end());
 
        return proof;
    }
 
    static std::vector<FF> cut_public_inputs_from_proof(std::vector<FF>& proof_witnesses,
                                                        const size_t num_public_inputs_to_extract)
    {
        // Construct iterators pointing to the start and end of the public inputs within the proof
        auto pub_inputs_begin_itr = proof_witnesses.begin();
        auto pub_inputs_end_itr = proof_witnesses.begin() + static_cast<std::ptrdiff_t>(num_public_inputs_to_extract);
 
        // Construct the isolated public inputs
        std::vector<FF> public_input_witnesses{ pub_inputs_begin_itr, pub_inputs_end_itr };
 
        // Erase the public inputs from the proof
        proof_witnesses.erase(pub_inputs_begin_itr, pub_inputs_end_itr);
 
        return public_input_witnesses;
    }
 
    static std::vector<uint32_t> get_public_inputs_witness_indices_from_proof(
        const bb::stdlib::Proof<bb::MegaCircuitBuilder>& proof, const size_t num_public_inputs_to_extract)
    {
        std::vector<uint32_t> public_input_witness_indices;
        public_input_witness_indices.reserve(num_public_inputs_to_extract);
 
        const size_t start = 0;
        const size_t end = start + num_public_inputs_to_extract;
        for (size_t i = start; i < end; ++i) {
            public_input_witness_indices.push_back(proof[i].get_witness_index());
        }
 
        return public_input_witness_indices;
    }
 
    struct RecursionWitnessData {
        std::vector<uint32_t> key_indices;
        uint32_t key_hash_index;
        std::vector<uint32_t> proof_indices;
        std::vector<uint32_t> public_inputs_indices;
    };
 
    static RecursionWitnessData populate_recursion_witness_data(bb::SlabVector<FF>& witness,
                                                                std::vector<FF>& proof_witnesses,
                                                                const std::vector<FF>& key_witnesses,
                                                                const FF& key_hash_witness,
                                                                const size_t num_public_inputs_to_extract)
    {
        // Extract all public inputs except for those corresponding to the aggregation object
        std::vector<FF> public_input_witnesses =
            cut_public_inputs_from_proof(proof_witnesses, num_public_inputs_to_extract);
 
        // Append key, proof, and public inputs while storing the associated witness indices
        std::vector<uint32_t> key_indices = add_to_witness_and_track_indices<FF>(witness, key_witnesses);
        uint32_t key_hash_index = static_cast<uint32_t>(witness.size());
        witness.emplace_back(key_hash_witness);
        std::vector<uint32_t> proof_indices = add_to_witness_and_track_indices<FF>(witness, proof_witnesses);
        std::vector<uint32_t> public_input_indices =
            add_to_witness_and_track_indices<FF>(witness, public_input_witnesses);
 
        return { key_indices, key_hash_index, proof_indices, public_input_indices };
    }
};
 
} // namespace acir_format