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;
 
    CommitmentKey(const size_t num_points)
        : srs(srs::get_crs_factory<Curve>()->get_crs(num_points))
        , srs_size(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 uint8_t> has_duplicates_hints = {}) 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, has_duplicates_hints);
        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;
        std::vector<uint8_t> has_duplicates_hints; // per-poly dedup opt-in (parallel to wires)
 
        std::vector<Commitment> commit_and_send_to_verifier(auto transcript)
        {
            std::vector<Commitment> commitments = key->batch_commit(wires, has_duplicates_hints);
            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)
        {
            wires.push_back(poly);
            labels.push_back(label);
            has_duplicates_hints.push_back(has_duplicates_hint ? uint8_t{ 1 } : uint8_t{ 0 });
        }
    };
 
    CommitBatch start_batch() { return CommitBatch{ this, {}, {} }; }
};
 
} // namespace bb