flavor.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/assert.hpp"
#include "barretenberg/common/ref_vector.hpp"
#include "barretenberg/common/std_array.hpp"
#include "barretenberg/common/std_vector.hpp"
#include "barretenberg/common/tuple.hpp"
#include "barretenberg/common/zip_view.hpp"
#include "barretenberg/constants.hpp"
#include "barretenberg/crypto/poseidon2/poseidon2.hpp"
#include "barretenberg/ecc/fields/field_conversion.hpp"
#include "barretenberg/honk/types/circuit_type.hpp"
#include "barretenberg/polynomials/barycentric.hpp"
#include "barretenberg/polynomials/evaluation_domain.hpp"
#include "barretenberg/polynomials/univariate.hpp"
#include "barretenberg/public_input_component/public_component_key.hpp"
#include "barretenberg/srs/global_crs.hpp"
#include "barretenberg/stdlib/hash/poseidon2/poseidon2.hpp"
#include "barretenberg/stdlib/primitives/field/field_conversion.hpp"
#include "barretenberg/transcript/transcript.hpp"
 
#include <array>
#include <concepts>
#include <cstddef>
#include <numeric>
#include <utility>
#include <vector>
 
namespace bb {
 
enum class VKSerializationMode : std::uint8_t {
    FULL,       // Serialize all metadata (log_circuit_size, num_public_inputs, pub_inputs_offset)
    NO_METADATA // Serialize only commitments, no metadata
};
 
// Specifies the regions of the execution trace containing non-trivial wire values
struct ActiveRegionData {
    void add_range(const size_t start, const size_t end)
    {
        BB_ASSERT_GTE(start, current_end, "Ranges should be non-overlapping and increasing.");
        ranges.emplace_back(start, end);
        for (size_t i = start; i < end; ++i) {
            idxs.push_back(i);
        }
        current_end = end;
    }
 
    std::vector<std::pair<size_t, size_t>> get_ranges() const { return ranges; }
    size_t get_idx(const size_t idx) const { return idxs[idx]; }
    std::pair<size_t, size_t> get_range(const size_t idx) const { return ranges.at(idx); }
    size_t size() const { return idxs.size(); }
    size_t num_ranges() const { return ranges.size(); }
 
  private:
    std::vector<std::pair<size_t, size_t>> ranges; // active ranges [start_i, end_i) of the execution trace
    std::vector<size_t> idxs;                      // full set of poly indices corresposponding to active ranges
    size_t current_end{ 0 };                       // end of last range; for ensuring monotonicity of ranges
};
 
struct MetaData {
    size_t dyadic_size = 0; // power-of-2 size of the execution trace
    size_t num_public_inputs = 0;
    size_t pub_inputs_offset = 0;
};
 
template <typename Polynomial, size_t NUM_PRECOMPUTED_ENTITIES> struct PrecomputedData_ {
    RefArray<Polynomial, NUM_PRECOMPUTED_ENTITIES> polynomials; // polys whose commitments comprise the VK
    MetaData metadata;                                          // execution trace metadata
};
 
template <typename PrecomputedCommitments,
          typename Transcript,
          VKSerializationMode SerializeMetadata = VKSerializationMode::FULL>
class NativeVerificationKey_ : public PrecomputedCommitments {
  public:
    using Commitment = typename PrecomputedCommitments::DataType;
    uint64_t log_circuit_size = 0;
    uint64_t num_public_inputs = 0;
    uint64_t pub_inputs_offset = 0;
 
    bool operator==(const NativeVerificationKey_&) const = default;
    virtual ~NativeVerificationKey_() = default;
    NativeVerificationKey_() = default;
    NativeVerificationKey_(const size_t circuit_size, const size_t num_public_inputs)
    {
        this->log_circuit_size = numeric::get_msb(circuit_size);
        this->num_public_inputs = num_public_inputs;
    };
 
    static size_t calc_num_data_types()
    {
        // Create a temporary instance to get the number of precomputed entities
        size_t commitments_size =
            PrecomputedCommitments::size() * Transcript::template calc_num_data_types<Commitment>();
        size_t metadata_size = 0;
        if constexpr (SerializeMetadata == VKSerializationMode::FULL) {
            // 3 metadata fields + commitments
            metadata_size = 3 * Transcript::template calc_num_data_types<uint64_t>();
        }
        // else NO_METADATA: metadata_size remains 0
        return metadata_size + commitments_size;
    }
 
    virtual std::vector<typename Transcript::DataType> to_field_elements() const
    {
 
        auto serialize = [](const auto& input, std::vector<typename Transcript::DataType>& buffer) {
            std::vector<typename Transcript::DataType> input_fields = Transcript::serialize(input);
            buffer.insert(buffer.end(), input_fields.begin(), input_fields.end());
        };
 
        std::vector<typename Transcript::DataType> elements;
 
        if constexpr (SerializeMetadata == VKSerializationMode::FULL) {
            serialize(this->log_circuit_size, elements);
            serialize(this->num_public_inputs, elements);
            serialize(this->pub_inputs_offset, elements);
        }
        // else NO_METADATA: skip metadata serialization
 
        for (const Commitment& commitment : this->get_all()) {
            serialize(commitment, elements);
        }
 
        NativeVerificationKey_ key;
        key.from_field_elements(elements);
        return elements;
    };
 
    size_t from_field_elements(const std::span<const typename Transcript::DataType>& elements)
    {
 
        size_t idx = 0;
        auto deserialize = [&idx, &elements]<typename T>(T& target) {
            size_t size = Transcript::template calc_num_data_types<T>();
            target = Transcript::template deserialize<T>(elements.subspan(idx, size));
            idx += size;
        };
 
        if constexpr (SerializeMetadata == VKSerializationMode::FULL) {
            deserialize(this->log_circuit_size);
            deserialize(this->num_public_inputs);
            deserialize(this->pub_inputs_offset);
        }
        // else NO_METADATA: skip metadata deserialization
 
        for (Commitment& commitment : this->get_all()) {
            deserialize(commitment);
        }
        return idx;
    }
 
    fr hash() const
    {
        // TODO(https://github.com/AztecProtocol/barretenberg/issues/1498): should hash be dependent on transcript?
        fr vk_hash = Transcript::hash(this->to_field_elements());
        return vk_hash;
    }
 
    virtual typename Transcript::DataType hash_through_transcript(const std::string& domain_separator,
                                                                  Transcript& transcript) const
    {
        transcript.add_to_independent_hash_buffer(domain_separator + "vk_log_circuit_size", this->log_circuit_size);
        transcript.add_to_independent_hash_buffer(domain_separator + "vk_num_public_inputs", this->num_public_inputs);
        transcript.add_to_independent_hash_buffer(domain_separator + "vk_pub_inputs_offset", this->pub_inputs_offset);
 
        for (const Commitment& commitment : this->get_all()) {
            transcript.add_to_independent_hash_buffer(domain_separator + "vk_commitment", commitment);
        }
 
        return transcript.hash_independent_buffer();
    }
};
 
template <typename Builder_,
          typename PrecomputedCommitments,
          VKSerializationMode SerializeMetadata = VKSerializationMode::FULL>
class StdlibVerificationKey_ : public PrecomputedCommitments {
  public:
    using Builder = Builder_;
    using FF = stdlib::field_t<Builder>;
    using Commitment = typename PrecomputedCommitments::DataType;
    using Transcript = StdlibTranscript<Builder>;
    FF log_circuit_size;
    FF num_public_inputs;
    FF pub_inputs_offset = 0;
 
    bool operator==(const StdlibVerificationKey_&) const = default;
    virtual ~StdlibVerificationKey_() = default;
    StdlibVerificationKey_() = default;
    StdlibVerificationKey_(const size_t circuit_size, const size_t num_public_inputs)
    {
        this->log_circuit_size = numeric::get_msb(circuit_size);
        this->num_public_inputs = num_public_inputs;
    };
 
    virtual std::vector<FF> to_field_elements() const
    {
        using Codec = stdlib::StdlibCodec<FF>;
 
        auto serialize_to_field_buffer = []<typename T>(const T& input, std::vector<FF>& buffer) {
            std::vector<FF> input_fields = Codec::template serialize_to_fields<T>(input);
            buffer.insert(buffer.end(), input_fields.begin(), input_fields.end());
        };
 
        std::vector<FF> elements;
 
        serialize_to_field_buffer(this->log_circuit_size, elements);
        serialize_to_field_buffer(this->num_public_inputs, elements);
        serialize_to_field_buffer(this->pub_inputs_offset, elements);
 
        for (const Commitment& commitment : this->get_all()) {
            serialize_to_field_buffer(commitment, elements);
        }
 
        return elements;
    };
 
    FF hash()
    {
        FF vk_hash = stdlib::poseidon2<Builder>::hash(to_field_elements());
        return vk_hash;
    }
 
    virtual FF hash_through_transcript(const std::string& domain_separator, Transcript& transcript) const
    {
        transcript.add_to_independent_hash_buffer(domain_separator + "vk_log_circuit_size", this->log_circuit_size);
        transcript.add_to_independent_hash_buffer(domain_separator + "vk_num_public_inputs", this->num_public_inputs);
        transcript.add_to_independent_hash_buffer(domain_separator + "vk_pub_inputs_offset", this->pub_inputs_offset);
        for (const Commitment& commitment : this->get_all()) {
            transcript.add_to_independent_hash_buffer(domain_separator + "vk_commitment", commitment);
        }
        return transcript.hash_independent_buffer();
    }
};
 
template <typename FF, typename VerificationKey> class VKAndHash_ {
  public:
    using Builder = VerificationKey::Builder;
    using NativeVerificationKey = VerificationKey::NativeVerificationKey;
 
    VKAndHash_() = default;
    VKAndHash_(const std::shared_ptr<VerificationKey>& vk)
        : vk(vk)
        , hash(vk->hash())
    {}
 
    VKAndHash_(const std::shared_ptr<VerificationKey>& vk, const FF& hash)
        : vk(vk)
        , hash(hash)
    {}
 
    VKAndHash_(Builder& builder, const std::shared_ptr<NativeVerificationKey>& native_vk)
        : vk(std::make_shared<VerificationKey>(&builder, native_vk))
        , hash(FF::from_witness(&builder, native_vk->hash()))
    {}
    std::shared_ptr<VerificationKey> vk;
    FF hash;
};
 
// Because of how Gemini is written, it is important to put the polynomials out in this order.
auto get_unshifted_then_shifted(const auto& all_entities)
{
    return concatenate(all_entities.get_unshifted(), all_entities.get_shifted());
};
 
template <typename Tuple> constexpr size_t compute_max_partial_relation_length()
{
    constexpr auto seq = std::make_index_sequence<std::tuple_size_v<Tuple>>();
    return []<std::size_t... Is>(std::index_sequence<Is...>) {
        return std::max({ std::tuple_element_t<Is, Tuple>::RELATION_LENGTH... });
    }(seq);
}
 
template <typename Tuple> constexpr size_t compute_max_total_relation_length()
{
    constexpr auto seq = std::make_index_sequence<std::tuple_size_v<Tuple>>();
    return []<std::size_t... Is>(std::index_sequence<Is...>) {
        return std::max({ std::tuple_element_t<Is, Tuple>::TOTAL_RELATION_LENGTH... });
    }(seq);
}
 
template <typename Tuple> constexpr size_t compute_number_of_subrelations()
{
    constexpr auto seq = std::make_index_sequence<std::tuple_size_v<Tuple>>();
    return []<std::size_t... I>(std::index_sequence<I...>) {
        return (0 + ... + std::tuple_element_t<I, Tuple>::SUBRELATION_PARTIAL_LENGTHS.size());
    }(seq);
}
 
template <typename Tuple, size_t NUM_INSTANCES, bool optimized = false>
constexpr auto create_protogalaxy_tuple_of_tuples_of_univariates()
{
    constexpr auto seq = std::make_index_sequence<std::tuple_size_v<Tuple>>();
    return []<size_t... I>(std::index_sequence<I...>) {
        if constexpr (optimized) {
            return flat_tuple::make_tuple(
                typename std::tuple_element_t<I, Tuple>::template ProtogalaxyTupleOfUnivariatesOverSubrelations<
                    NUM_INSTANCES>{}...);
        } else {
            return flat_tuple::make_tuple(
                typename std::tuple_element_t<I, Tuple>::
                    template ProtogalaxyTupleOfUnivariatesOverSubrelationsNoOptimisticSkipping<NUM_INSTANCES>{}...);
        }
    }(seq);
}
 
template <typename RelationsTuple> constexpr auto create_sumcheck_tuple_of_tuples_of_univariates()
{
    constexpr auto seq = std::make_index_sequence<std::tuple_size_v<RelationsTuple>>();
    return []<size_t... I>(std::index_sequence<I...>) {
        return flat_tuple::make_tuple(
            typename std::tuple_element_t<I, RelationsTuple>::SumcheckTupleOfUnivariatesOverSubrelations{}...);
    }(seq);
}
 
template <typename RelationsTuple> constexpr auto create_tuple_of_arrays_of_values()
{
    constexpr auto seq = std::make_index_sequence<std::tuple_size_v<RelationsTuple>>();
    return []<size_t... I>(std::index_sequence<I...>) {
        return flat_tuple::make_tuple(
            typename std::tuple_element_t<I, RelationsTuple>::SumcheckArrayOfValuesOverSubrelations{}...);
    }(seq);
}
 
} // namespace bb
 
// Forward declare honk flavors
namespace bb {
class UltraFlavor;
class UltraZKFlavor;
class UltraRollupFlavor;
class ECCVMFlavor;
class UltraKeccakFlavor;
#ifdef STARKNET_GARAGA_FLAVORS
class UltraStarknetFlavor;
class UltraStarknetZKFlavor;
#endif
class UltraKeccakZKFlavor;
class MegaFlavor;
class MegaZKFlavor;
class TranslatorFlavor;
class ECCVMRecursiveFlavor;
class TranslatorRecursiveFlavor;
class AvmRecursiveFlavor;
class MultilinearBatchingRecursiveFlavor;
 
template <typename BuilderType> class UltraRecursiveFlavor_;
template <typename BuilderType> class UltraZKRecursiveFlavor_;
template <typename BuilderType> class UltraRollupRecursiveFlavor_;
template <typename BuilderType> class MegaRecursiveFlavor_;
template <typename BuilderType> class MegaZKRecursiveFlavor_;
 
// Serialization methods for NativeVerificationKey_.
// These should cover all base classes that do not need additional members, as long as the appropriate SerializeMetadata
// is set in the template parameters.
template <typename PrecomputedCommitments, typename Transcript, VKSerializationMode SerializeMetadata>
inline void read(uint8_t const*& it, NativeVerificationKey_<PrecomputedCommitments, Transcript, SerializeMetadata>& vk)
{
    using serialize::read;
 
    // Get the size directly from the static method
    size_t num_frs =
        NativeVerificationKey_<PrecomputedCommitments, Transcript, SerializeMetadata>::calc_num_data_types();
 
    // Read exactly num_frs field elements from the buffer
    std::vector<typename Transcript::DataType> field_elements(num_frs);
    for (auto& element : field_elements) {
        read(it, element);
    }
    // Then use from_field_elements to populate the verification key
    vk.from_field_elements(field_elements);
}
 
template <typename PrecomputedCommitments, typename Transcript, VKSerializationMode SerializeMetadata>
inline void write(std::vector<uint8_t>& buf,
                  NativeVerificationKey_<PrecomputedCommitments, Transcript, SerializeMetadata> const& vk)
{
    using serialize::write;
    size_t before = buf.size();
    // Convert to field elements and write them directly without length prefix
    auto field_elements = vk.to_field_elements();
    for (const auto& element : field_elements) {
        write(buf, element);
    }
    size_t after = buf.size();
    size_t num_frs =
        NativeVerificationKey_<PrecomputedCommitments, Transcript, SerializeMetadata>::calc_num_data_types();
    BB_ASSERT_EQ(after - before, num_frs * sizeof(bb::fr), "VK serialization mismatch");
}
 
namespace avm2 {
class AvmRecursiveFlavor;
}
 
} // namespace bb