acir_to_constraint_buf.hpp

Go to the documentation of this file.

// === AUDIT STATUS ===
// internal:    { status: Complete, auditors: [Federico], commit: 2094fd1467dd9a94803b2c5007cf60ac357aa7d2 }
// external_1:  { status: not started, auditors: [], commit: }
// external_2:  { status: not started, auditors: [], commit: }
// =====================
 
#pragma once
#include "acir_format.hpp"
#include "serde/index.hpp"
 
namespace acir_format {
 
 
 
bb::fr from_buffer_with_bound_checks(const std::vector<uint8_t>& buffer);
 
WitnessOrConstant<bb::fr> parse_input(const Acir::FunctionInput& input);
 
uint32_t get_witness_from_function_input(const Acir::FunctionInput& input);
 
void update_max_witness_index(const uint32_t witness_idx, AcirFormat& af);
 
void update_max_witness_index_from_expression(Acir::Expression const& expr, AcirFormat& af);
 
void update_max_witness_index_from_opcode(Acir::Opcode const& opcode, AcirFormat& af);
 
 
 
template <typename T>
T deserialize_msgpack_compact(std::vector<uint8_t>&& buf, std::function<T(msgpack::object const&)> decode_msgpack);
 
AcirFormat circuit_serde_to_acir_format(Acir::Circuit const& circuit, bool is_mega);
 
WitnessVector witness_map_to_witness_vector(Witnesses::WitnessMap const& witness_map);
 
AcirFormat circuit_buf_to_acir_format(std::vector<uint8_t>&& buf, bool is_mega);
 
AcirFormat circuit_buf_to_mega_acir_format(std::vector<uint8_t>&& buf);
 
WitnessVector witness_buf_to_witness_vector(std::vector<uint8_t>&& buf);
 
 
 
std::map<uint32_t, bb::fr> process_linear_terms(Acir::Expression const& expr);
 
enum class AssertZeroGate : uint8_t { Bilinear, BatchedEq, SingleArithmetic, MultiArithmetic };
 
AssertZeroGate classify_assert_zero(Acir::Expression const& arg,
                                    const std::map<uint32_t, bb::fr>& linear_terms,
                                    bool is_mega);
 
bool resolve_shared_wire_products(Acir::Expression const& arg, uint32_t& w_l, uint32_t& w_r, uint32_t& w_o);
 
bool is_bilinear(Acir::Expression const& arg, const std::map<uint32_t, bb::fr>& linear_terms);
 
bool is_batched_eq(Acir::Expression const& arg, const std::map<uint32_t, bb::fr>& linear_terms);
 
bool is_single_arithmetic_gate(Acir::Expression const& arg, const std::map<uint32_t, bb::fr>& linear_terms);
 
BilinearConstraint build_bilinear_constraint(Acir::Expression const& arg,
                                             const std::map<uint32_t, bb::fr>& linear_terms);
 
// clang-format off
// clang-format on
std::vector<mul_quad_<fr>> split_into_mul_quad_gates(Acir::Expression const& arg,
                                                     std::map<uint32_t, bb::fr>& linear_terms);
 
struct BatchedEqEntry {
    uint32_t w1;
    uint32_t w2;
    bb::fr c1;
    bb::fr c2;
    bb::fr q_c;
    size_t opcode_index;
};
 
BatchedEqEntry build_batched_eq_entry(Acir::Expression const& arg,
                                      const std::map<uint32_t, bb::fr>& linear_terms,
                                      size_t opcode_index);
 
BatchedEqCheckConstraint build_batched_eq_check_constraint(const BatchedEqEntry& entry1,
                                                           const std::optional<BatchedEqEntry>& entry2);
 
void assert_zero_to_constraints(Acir::Opcode::AssertZero const& arg,
                                AcirFormat& af,
                                size_t opcode_index,
                                std::vector<BatchedEqEntry>& batched_eq_assert_zeros,
                                bool is_mega);
 
void batched_eq_assert_zeros_into_constraints(AcirFormat& af, std::vector<BatchedEqEntry>& pending);
 
 
BlockConstraint memory_init_to_block_constraint(Acir::Opcode::MemoryInit const& mem_init);
 
void add_memory_op_to_block_constraint(Acir::Opcode::MemoryOp const& mem_op, BlockConstraint& block);
 
 
void add_blackbox_func_call_to_acir_format(Acir::Opcode::BlackBoxFuncCall const& arg,
                                           AcirFormat& af,
                                           size_t opcode_index);
 
} // namespace acir_format