recursive_flavor.hpp

Go to the documentation of this file.

// === AUDIT STATUS ===
// internal:    { status: Planned, auditors: [Federico], commit: }
// external_1:  { status: not started, auditors: [], commit: }
// external_2:  { status: not started, auditors: [], commit: }
// =====================
 
#pragma once
 
#include <cstdint>
 
#include "barretenberg/flavor/flavor.hpp"
#include "barretenberg/stdlib_circuit_builders/ultra_circuit_builder.hpp"
#include "barretenberg/vm2/constraining/flavor.hpp"
#include "barretenberg/vm2/constraining/recursion/recursive_flavor_settings.hpp"
 
namespace bb::avm2 {
 
class AvmRecursiveFlavor {
  public:
    using CircuitBuilder = AvmRecursiveFlavorSettings::CircuitBuilder;
    using Curve = AvmRecursiveFlavorSettings::Curve;
    using PCS = AvmRecursiveFlavorSettings::PCS;
    using GroupElement = AvmRecursiveFlavorSettings::GroupElement;
    using Commitment = AvmRecursiveFlavorSettings::Commitment;
    using FF = AvmRecursiveFlavorSettings::FF;
    using BF = AvmRecursiveFlavorSettings::BF;
 
    using NativeFlavor = avm2::AvmFlavor;
    using NativeVerificationKey = NativeFlavor::VerificationKey;
    using Transcript = StdlibTranscript<CircuitBuilder>;
 
    // Native one is used!
    using VerifierCommitmentKey = NativeFlavor::VerifierCommitmentKey;
 
    using Relations = NativeFlavor::Relations_<FF>;
 
    static constexpr size_t NUM_ALL_ENTITIES = NativeFlavor::NUM_ALL_ENTITIES;
    static constexpr size_t BATCHED_RELATION_PARTIAL_LENGTH = NativeFlavor::BATCHED_RELATION_PARTIAL_LENGTH;
    static constexpr size_t NUM_RELATIONS = std::tuple_size_v<Relations>;
 
    static constexpr size_t NUM_SUBRELATIONS = NativeFlavor::NUM_SUBRELATIONS;
    using SubrelationSeparators = std::array<FF, NUM_SUBRELATIONS - 1>;
 
    // This flavor would not be used with ZK Sumcheck
    static constexpr bool HasZK = false;
 
    // To achieve fixed proof size and that the recursive verifier circuit is constant, we are using padding in Sumcheck
    // and Shplemini
    static constexpr bool USE_PADDING = true;
 
    class AllValues : public NativeFlavor::AllEntities<FF> {
      public:
        using Base = NativeFlavor::AllEntities<FF>;
        using Base::Base;
    };
 
    class VerificationKey : public StdlibVerificationKey_<CircuitBuilder,
                                                          NativeFlavor::PrecomputedEntities<Commitment>,
                                                          NativeVerificationKey,
                                                          VKSerializationMode::NO_METADATA> {
      public:
        size_t log_fixed_circuit_size = MAX_AVM_TRACE_LOG_SIZE;
        VerificationKey(CircuitBuilder* builder, const std::shared_ptr<NativeVerificationKey>& native_key)
        {
            for (auto [native_comm, comm] : zip_view(native_key->get_all(), this->get_all())) {
                comm = Commitment::from_witness(builder, native_comm);
            }
        }
 
        VerificationKey(std::span<const FF> elements)
        {
            using Codec = stdlib::StdlibCodec<FF>;
 
            size_t num_frs_read = 0;
            size_t num_frs_Comm = Codec::template calc_num_fields<Commitment>();
 
            for (Commitment& comm : this->get_all()) {
                comm =
                    Codec::template deserialize_from_fields<Commitment>(elements.subspan(num_frs_read, num_frs_Comm));
                num_frs_read += num_frs_Comm;
            }
        }
 
        FF hash_with_origin_tagging([[maybe_unused]] const OriginTag& tag) const override
        {
            throw_or_abort("Not intended to be used because vk is hardcoded in circuit.");
        }
 
        void fix_witness()
        {
            for (Commitment& commitment : this->get_all()) {
                commitment.fix_witness();
            }
        }
    };
 
    using WitnessCommitments = NativeFlavor::WitnessEntities<Commitment>;
    using VerifierCommitments = NativeFlavor::VerifierCommitments_<Commitment, VerificationKey>;
};
 
} // namespace bb::avm2