utility.hpp

#pragma once
 
#include "barretenberg/ecc/curves/bn254/fq.hpp"
#include "barretenberg/ecc/curves/bn254/fr.hpp"
#include "barretenberg/ecc/curves/bn254/g1.hpp"
#include "barretenberg/polynomials/univariate.hpp"
 
#include "barretenberg/transcript/transcript.hpp"
 
#include "barretenberg/stdlib/primitives/bigfield/bigfield.hpp"
#include "barretenberg/stdlib/primitives/biggroup/biggroup.hpp"
#include "barretenberg/stdlib/primitives/field/field.hpp"
 
namespace proof_system::plonk::stdlib::recursion::utility {
 
template <typename Builder> class StdlibTypesUtility {
    using field_ct = field_t<Builder>;
    using fq_ct = bigfield<Builder, barretenberg::Bn254FqParams>;
    using element_ct = element<Builder, fq_ct, field_ct, barretenberg::g1>;
    using FF = barretenberg::fr;
    using Commitment = barretenberg::g1::affine_element;
    template <size_t LENGTH> using Univariate = barretenberg::Univariate<FF, LENGTH>;
    template <size_t LENGTH> using Univariate_ct = barretenberg::Univariate<field_ct, LENGTH>;
 
  public:
    static field_ct from_witness(Builder* builder, uint32_t native_element)
    {
        return field_ct::from_witness(builder, native_element);
    }
 
    static field_ct from_witness(Builder* builder, FF native_element)
    {
        return field_ct::from_witness(builder, native_element);
    }
 
    static element_ct from_witness(Builder* builder, Commitment native_element)
    {
        return element_ct::from_witness(builder, native_element);
    }
 
    template <size_t LENGTH>
    static std::array<field_ct, LENGTH> from_witness(Builder* builder, std::array<FF, LENGTH> native_element)
    {
        std::array<field_ct, LENGTH> element;
        for (size_t i = 0; i < LENGTH; ++i) {
            element[i] = field_ct::from_witness(builder, native_element[i]);
        }
        return element;
    }
 
    template <size_t LENGTH>
    static Univariate_ct<LENGTH> from_witness(Builder* builder, Univariate<LENGTH> native_element)
    {
        Univariate_ct<LENGTH> element;
        for (size_t i = 0; i < LENGTH; ++i) {
            element.value_at(i) = field_ct::from_witness(builder, native_element.value_at(i));
        }
        return element;
    }
 
    template <typename T, size_t LENGTH = 0> struct NativeType {
        using type = void;
    };
 
    template <size_t LENGTH> struct NativeType<uint32_t, LENGTH> {
        using type = uint32_t;
    };
 
    template <size_t LENGTH> struct NativeType<field_ct, LENGTH> {
        using type = FF;
    };
 
    template <size_t LENGTH> struct NativeType<element_ct, LENGTH> {
        using type = Commitment;
    };
 
    template <size_t LENGTH> struct NativeType<std::array<field_ct, LENGTH>, 0> {
        using type = std::array<FF, LENGTH>;
    };
 
    template <size_t LENGTH> struct NativeType<Univariate_ct<LENGTH>, 0> {
        using type = Univariate<LENGTH>;
    };
};
} // namespace proof_system::plonk::stdlib::recursion::utility