recursion_constraint.hpp

#pragma once
#include "barretenberg/dsl/types.hpp"
#include "barretenberg/plonk/proof_system/verification_key/verification_key.hpp"
#include <vector>
 
namespace acir_format {
 
using namespace proof_system::plonk;
 
struct RecursionConstraint {
    // An aggregation state is represented by two G1 affine elements. Each G1 point has
    // two field element coordinates (x, y). Thus, four field elements
    static constexpr size_t NUM_AGGREGATION_ELEMENTS = 4;
    // Four limbs are used when simulating a non-native field using the bigfield class
    static constexpr size_t AGGREGATION_OBJECT_SIZE =
        NUM_AGGREGATION_ELEMENTS * NUM_QUOTIENT_PARTS; // 16 field elements
    std::vector<uint32_t> key;
    std::vector<uint32_t> proof;
    std::vector<uint32_t> public_inputs;
    uint32_t key_hash;
    // TODO(maxim):This is now unused, but we keep it here for backwards compatibility
    std::array<uint32_t, AGGREGATION_OBJECT_SIZE> input_aggregation_object;
    // TODO(maxim): This is now unused, but we keep it here for backwards compatibility
    std::array<uint32_t, AGGREGATION_OBJECT_SIZE> output_aggregation_object;
    // TODO(maxim): This is currently not being used on the Noir level at all,
    // TODO(maxim): but we keep it here for backwards compatibility
    // TODO(maxim): The object is now currently contained by the `proof` field
    // TODO(maxim): and is handled when serializing ACIR to a barretenberg circuit
    std::array<uint32_t, AGGREGATION_OBJECT_SIZE> nested_aggregation_object;
 
    friend bool operator==(RecursionConstraint const& lhs, RecursionConstraint const& rhs) = default;
};
 
std::array<uint32_t, RecursionConstraint::AGGREGATION_OBJECT_SIZE> create_recursion_constraints(
    Builder& builder,
    const RecursionConstraint& input,
    std::array<uint32_t, RecursionConstraint::AGGREGATION_OBJECT_SIZE> input_aggregation_object,
    std::array<uint32_t, RecursionConstraint::AGGREGATION_OBJECT_SIZE> nested_aggregation_object,
    bool has_valid_witness_assignments = false);
 
std::vector<barretenberg::fr> export_key_in_recursion_format(std::shared_ptr<verification_key> const& vkey);
std::vector<barretenberg::fr> export_dummy_key_in_recursion_format(const PolynomialManifest& polynomial_manifest,
                                                                   bool contains_recursive_proof = 0);
 
std::vector<barretenberg::fr> export_transcript_in_recursion_format(const transcript::StandardTranscript& transcript);
std::vector<barretenberg::fr> export_dummy_transcript_in_recursion_format(const transcript::Manifest& manifest,
                                                                          const bool contains_recursive_proof);
size_t recursion_proof_size_without_public_inputs();
 
// In order to interact with a recursive aggregation state inside of a circuit, we need to represent its internal G1
// elements as field elements. This happens in multiple locations when creating a recursion constraint. The struct and
// method below export a g1 affine element as fields to use as part of the recursive circuit.
struct G1AsFields {
    barretenberg::fr x_lo;
    barretenberg::fr x_hi;
    barretenberg::fr y_lo;
    barretenberg::fr y_hi;
};
G1AsFields export_g1_affine_element_as_fields(const barretenberg::g1::affine_element& group_element);
 
template <typename B> inline void read(B& buf, RecursionConstraint& constraint)
{
    using serialize::read;
    read(buf, constraint.key);
    read(buf, constraint.proof);
    read(buf, constraint.public_inputs);
    read(buf, constraint.key_hash);
    read(buf, constraint.input_aggregation_object);
    read(buf, constraint.output_aggregation_object);
    read(buf, constraint.nested_aggregation_object);
}
 
template <typename B> inline void write(B& buf, RecursionConstraint const& constraint)
{
    using serialize::write;
    write(buf, constraint.key);
    write(buf, constraint.proof);
    write(buf, constraint.public_inputs);
    write(buf, constraint.key_hash);
    write(buf, constraint.input_aggregation_object);
    write(buf, constraint.output_aggregation_object);
    write(buf, constraint.nested_aggregation_object);
}
 
} // namespace acir_format