recursion_constraint.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/serialize.hpp"
#include "barretenberg/dsl/acir_format/witness_constant.hpp"
#include "barretenberg/stdlib/primitives/field/field.hpp"
#include <cstdint>
#include <vector>
 
namespace acir_format {
 
// Used to specify the type of recursive verifier via the proof_type specified by the RecursiveAggregation opcode from
// ACIR
// Keep this enum values in sync with their noir counterpart constants defined in
// noir-protocol-circuits/crates/types/src/constants.nr
enum PROOF_TYPE { PLONK, HONK, OINK, PG, AVM, ROLLUP_HONK, ROOT_ROLLUP_HONK, HONK_ZK, PG_FINAL, PG_TAIL, CIVC };
 
struct RecursionConstraint {
    std::vector<uint32_t> key;
    std::vector<uint32_t> proof;
    std::vector<uint32_t> public_inputs;
    uint32_t key_hash;
    uint32_t proof_type;
    WitnessOrConstant<bb::fr> predicate;
 
    friend bool operator==(RecursionConstraint const& lhs, RecursionConstraint const& rhs) = default;
 
    template <typename Builder>
    static std::vector<bb::stdlib::field_t<Builder>> fields_from_witnesses(Builder& builder,
                                                                           const std::vector<uint32_t>& witness_indices)
    {
        std::vector<bb::stdlib::field_t<Builder>> result;
        result.reserve(witness_indices.size());
        for (const auto& idx : witness_indices) {
            result.emplace_back(bb::stdlib::field_t<Builder>::from_witness_index(&builder, idx));
        }
        return result;
    }
};
 
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.predicate);
}
 
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.predicate);
}
 
} // namespace acir_format