pairing_points.hpp

Go to the documentation of this file.

// === AUDIT STATUS ===
// internal:    { status: complete, auditors: [Luke], commit: }
// external_1:  { status: not started, auditors: [], commit: }
// external_2:  { status: not started, auditors: [], commit: }
// =====================
 
#pragma once
 
#include "barretenberg/commitment_schemes/verification_key.hpp"
#include "barretenberg/common/assert.hpp"
#include "barretenberg/common/bb_bench.hpp"
 
namespace bb {
 
template <typename Curve_> class PairingPoints {
  public:
    using Curve = Curve_;
    using Point = typename Curve::AffineElement;
    using Fr = typename Curve::ScalarField;
    using Fq = typename Curve::BaseField;
    using VerifierCK = VerifierCommitmentKey<curve::BN254>;
 
    static constexpr size_t PUBLIC_INPUTS_SIZE = PAIRING_POINTS_SIZE;
 
    // Array-like interface for Codec compatibility
    using value_type = Point;
    static constexpr size_t SIZE = 2;
 
    // Named accessors
    Point& P0() { return _points[0]; }
    Point& P1() { return _points[1]; }
    const Point& P0() const { return _points[0]; }
    const Point& P1() const { return _points[1]; }
 
    PairingPoints() = default;
    PairingPoints(const Point& p0, const Point& p1)
        : _points{ p0, p1 }
    {}
 
    // Iterator support for range-based for (required by Codec)
    auto begin() { return _points.begin(); }
    auto end() { return _points.end(); }
    auto begin() const { return _points.begin(); }
    auto end() const { return _points.end(); }
    static constexpr size_t size() { return SIZE; }
 
    void aggregate(const PairingPoints<Curve>& other)
    {
        const bool this_p0_inf = (P0() == Point::infinity());
        const bool this_p1_inf = (P1() == Point::infinity());
        const bool other_p0_inf = (other.P0() == Point::infinity());
        const bool other_p1_inf = (other.P1() == Point::infinity());
 
        const bool this_is_default = this_p0_inf && this_p1_inf;
        const bool this_is_mixed = this_p0_inf != this_p1_inf;
        const bool other_is_default = other_p0_inf && other_p1_inf;
        const bool other_is_mixed = other_p0_inf != other_p1_inf;
 
        if (other_is_default || other_is_mixed) {
            throw_or_abort("Cannot aggregate: incoming pairing points are at infinity or mixed-infinity.");
        }
        if (this_is_mixed) {
            throw_or_abort("Cannot aggregate: accumulator pairing points are mixed-infinity (corrupted state).");
        }
        // Only a fully-default accumulator is uninitialized; adopt the incoming points.
        if (this_is_default) {
            *this = other;
            return;
        }
        Fr aggregation_separator = Fr::random_element();
        P0() = P0() + other.P0() * aggregation_separator;
        P1() = P1() + other.P1() * aggregation_separator;
    }
 
    bool check() const
    {
        BB_BENCH_NAME("PairingPoints::check");
        VerifierCK vck{};
        // TODO(https://github.com/AztecProtocol/barretenberg/issues/1423): Rename to verifier_pcs_key or vckey or
        // something. Issue exists in many places besides just here.
        return vck.pairing_check(P0(), P1());
    }
 
  private:
    std::array<Point, 2> _points = { Point::infinity(), Point::infinity() };
};
 
} // namespace bb
 
// Enable std::tuple_size for Codec compatibility (array-like deserialization)
namespace std {
template <typename Curve> struct tuple_size<bb::PairingPoints<Curve>> : std::integral_constant<size_t, 2> {};
} // namespace std