commitment_key.hpp

Go to the documentation of this file.

// === AUDIT STATUS ===
// internal:    { status: Planned, auditors: [Sergei], commit: }
// external_1:  { status: not started, auditors: [], commit: }
// external_2:  { status: not started, auditors: [], commit: }
// =====================
 
#pragma once
 
#include "barretenberg/common/bb_bench.hpp"
#include "barretenberg/common/log.hpp"
#include "barretenberg/common/ref_span.hpp"
#include "barretenberg/ecc/scalar_multiplication/scalar_multiplication.hpp"
#include "barretenberg/polynomials/polynomial.hpp"
#include "barretenberg/srs/factories/crs_factory.hpp"
#include "barretenberg/srs/global_crs.hpp"
 
#include <algorithm>
#include <array>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <limits>
#include <memory>
#include <string_view>
 
namespace bb {
template <class Curve> class CommitmentKey {
 
    using Fr = typename Curve::ScalarField;
    using Commitment = typename Curve::AffineElement;
 
  protected:
    std::shared_ptr<srs::factories::Crs<Curve>> srs;
 
  public:
    size_t srs_size;
 
    CommitmentKey() = default;
 
    static constexpr size_t round_up_to_even(size_t n) { return (n + 1) & ~size_t{ 1 }; }
 
    CommitmentKey(const size_t num_points)
        : srs(srs::get_crs_factory<Curve>()->get_crs(round_up_to_even(num_points)))
        , srs_size(round_up_to_even(num_points))
    {}
    bool initialized() const { return srs != nullptr; }
 
    std::span<Commitment> get_monomial_points() const { return srs->get_monomial_points(); }
    size_t get_monomial_size() const { return srs->get_monomial_size(); }
 
    Commitment commit(PolynomialSpan<const Fr> polynomial, bool has_duplicates_hint = false) const
    {
        BB_BENCH_NAME("CommitmentKey::commit");
        std::span<const Commitment> point_table = get_monomial_points();
        size_t consumed_srs = polynomial.start_index + polynomial.size();
        if (consumed_srs > get_monomial_size()) {
            throw_or_abort(format("Attempting to commit to a polynomial that needs ",
                                  consumed_srs,
                                  " points with an SRS of size ",
                                  get_monomial_size()));
        }
        return scalar_multiplication::pippenger_unsafe<Curve>(polynomial, point_table, has_duplicates_hint);
    };
    std::vector<Commitment> batch_commit(RefSpan<Polynomial<Fr>> polynomials,
                                         std::span<const uint32_t> dedup_infos = {}) const
    {
        BB_BENCH_NAME("CommitmentKey::batch_commit");
 
        std::vector<PolynomialSpan<Fr>> scalar_spans;
        scalar_spans.reserve(polynomials.size());
 
        for (auto& polynomial : polynomials) {
            const size_t consumed_srs = polynomial.start_index() + polynomial.size();
            if (consumed_srs > get_monomial_size()) {
                throw_or_abort(format("Attempting to commit to a polynomial that needs ",
                                      consumed_srs,
                                      " points with an SRS of size ",
                                      get_monomial_size()));
            }
            scalar_spans.emplace_back(polynomial.start_index(), polynomial.coeffs());
        }
 
        auto results = scalar_multiplication::MSM<Curve>::batch_multi_scalar_mul(
            get_monomial_points(), scalar_spans, /*handle_edge_cases=*/false, dedup_infos);
        return std::vector<Commitment>(results.begin(), results.end());
    };
 
    // helper builder struct for constructing a batch to commit at once
    struct CommitBatch {
        CommitmentKey* key;
        RefVector<Polynomial<Fr>> wires;
        std::vector<std::string> labels;
        // Per-poly dedup channel (parallel to wires): 0 = off, 1 = hinted with no
        // estimate, k >= 2 = hinted with a measured duplicate count of k.
        std::vector<uint32_t> dedup_infos;
 
        std::vector<Commitment> commit_and_send_to_verifier(auto transcript)
        {
            std::vector<Commitment> commitments = key->batch_commit(wires, dedup_infos);
            for (size_t i = 0; i < commitments.size(); ++i) {
                transcript->send_to_verifier(labels[i], commitments[i]);
            }
            return commitments;
        }
 
        void add_to_batch(Polynomial<Fr>& poly,
                          const std::string& label,
                          bool has_duplicates_hint = false,
                          uint32_t measured_duplicate_count = 0)
        {
            wires.push_back(poly);
            labels.push_back(label);
            dedup_infos.push_back(has_duplicates_hint ? std::max<uint32_t>(1, measured_duplicate_count)
                                                      : uint32_t{ 0 });
        }
    };
 
    CommitBatch start_batch() { return CommitBatch{ this, {}, {} }; }
};
 
} // namespace bb