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
};
 
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;
 
#ifndef NDEBUG
    template <size_t NUM_PRECOMPUTED_ENTITIES, typename StringType>
    bool compare(const NativeVerificationKey_& other,
                 RefArray<StringType, NUM_PRECOMPUTED_ENTITIES> commitment_labels) const
    {
        bool is_equal = true;
 
        if (this->log_circuit_size != other.log_circuit_size) {
            info("Log circuit size mismatch: ", this->log_circuit_size, " vs ", other.log_circuit_size);
            is_equal = false;
        }
 
        if (this->num_public_inputs != other.num_public_inputs) {
            info("Num public inputs mismatch: ", this->num_public_inputs, " vs ", other.num_public_inputs);
            is_equal = false;
        }
 
        if (this->pub_inputs_offset != other.pub_inputs_offset) {
            info("Pub inputs offset mismatch: ", this->pub_inputs_offset, " vs ", other.pub_inputs_offset);
            is_equal = false;
        }
 
        for (auto [this_comm, other_comm, label] : zip_view(this->get_all(), other.get_all(), commitment_labels)) {
            if (this_comm != other_comm) {
                info("Commitment mismatch: ", label);
                is_equal = false;
            }
        }
        return is_equal;
    }
#endif
 
    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::Codec::template calc_num_fields<Commitment>();
        size_t metadata_size = 0;
        if constexpr (SerializeMetadata == VKSerializationMode::FULL) {
            // 3 metadata fields + commitments
            metadata_size = 3 * Transcript::Codec::template calc_num_fields<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::Codec::template calc_num_fields<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
    {
        fr vk_hash = Transcript::HashFunction::hash(this->to_field_elements());
        return vk_hash;
    }
 
    virtual typename Transcript::DataType hash_with_origin_tagging([[maybe_unused]] const std::string& domain_separator,
                                                                   Transcript& transcript) const
    {
        using DataType = typename Transcript::DataType;
        using Codec = typename Transcript::Codec;
        std::vector<DataType> vk_elements;
 
        const OriginTag tag = bb::extract_transcript_tag(transcript);
 
        // Tag, serialize, and append to vk_elements
        auto tag_and_append = [&]<typename T>(const T& component) {
            auto frs = bb::tag_and_serialize<Transcript::in_circuit, Codec>(component, tag);
            vk_elements.insert(vk_elements.end(), frs.begin(), frs.end());
        };
 
        // Tag and serialize VK metadata
        tag_and_append(this->log_circuit_size);
        tag_and_append(this->num_public_inputs);
        tag_and_append(this->pub_inputs_offset);
 
        // Tag and serialize VK commitments
        for (const Commitment& commitment : this->get_all()) {
            tag_and_append(commitment);
        }
 
        // Sanitize free witness tags before hashing
        bb::unset_free_witness_tags<Transcript::in_circuit, DataType>(vk_elements);
 
        // Hash the tagged elements directly
        return Transcript::HashFunction::hash(vk_elements);
    }
};
 
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_with_origin_tagging([[maybe_unused]] const std::string& domain_separator,
                                        Transcript& transcript) const
    {
        using Codec = stdlib::StdlibCodec<FF>;
        std::vector<FF> vk_elements;
 
        const OriginTag tag = bb::extract_transcript_tag(transcript);
 
        // Tag, serialize, and append to vk_elements
        auto append_tagged = [&]<typename T>(const T& component) {
            auto frs = bb::tag_and_serialize<Transcript::in_circuit, Codec>(component, tag);
            vk_elements.insert(vk_elements.end(), frs.begin(), frs.end());
        };
 
        // Tag and serialize VK metadata
        append_tagged(this->log_circuit_size);
        append_tagged(this->num_public_inputs);
        append_tagged(this->pub_inputs_offset);
 
        // Tag and serialize VK commitments
        for (const Commitment& commitment : this->get_all()) {
            append_tagged(commitment);
        }
 
        // Sanitize free witness tags before hashing
        bb::unset_free_witness_tags<Transcript::in_circuit, FF>(vk_elements);
 
        // Hash the tagged elements directly
        return Transcript::HashFunction::hash(vk_elements);
    }
};
 
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_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 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