acir_format.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 "aes128_constraint.hpp"
#include "avm2_recursion_constraint.hpp"
#include "barretenberg/circuit_checker/circuit_checker.hpp"
 
#include "arithmetic_constraints.hpp"
#include "barretenberg/chonk/chonk.hpp"
#include "blake2s_constraint.hpp"
#include "blake3_constraint.hpp"
#include "block_constraint.hpp"
#include "chonk_recursion_constraints.hpp"
#include "ec_operations.hpp"
#include "ecdsa_constraints.hpp"
#include "honk_recursion_constraint.hpp"
#include "hypernova_recursion_constraint.hpp"
#include "keccak_constraint.hpp"
#include "logic_constraint.hpp"
#include "multi_scalar_mul.hpp"
#include "poseidon2_constraint.hpp"
#include "range_constraint.hpp"
#include "recursion_constraint.hpp"
#include "sha256_constraint.hpp"
#include <array>
#include <cstdint>
#include <utility>
#include <vector>
 
namespace acir_format {
 
using WitnessVector = std::vector<bb::fr>;
 
struct AcirFormatOriginalOpcodeIndices {
    std::vector<size_t> logic_constraints;
    std::vector<size_t> range_constraints;
    std::vector<size_t> aes128_constraints;
    std::vector<size_t> sha256_compression;
    std::vector<size_t> ecdsa_k1_constraints;
    std::vector<size_t> ecdsa_r1_constraints;
    std::vector<size_t> blake2s_constraints;
    std::vector<size_t> blake3_constraints;
    std::vector<size_t> keccak_permutations;
    std::vector<size_t> poseidon2_constraints;
    std::vector<size_t> multi_scalar_mul_constraints;
    std::vector<size_t> ec_add_constraints;
    std::vector<size_t> honk_recursion_constraints;
    std::vector<size_t> avm_recursion_constraints;
    std::vector<size_t> hn_recursion_constraints;
    std::vector<size_t> chonk_recursion_constraints;
    std::vector<size_t> quad_constraints;
    std::vector<size_t> big_quad_constraints;
    std::vector<size_t> bilinear_constraints;
    std::vector<std::array<size_t, 2>> batched_eq_check_constraints;
    // Multiple opcode indices per block:
    std::vector<std::vector<size_t>> block_constraints;
 
    friend bool operator==(AcirFormatOriginalOpcodeIndices const& lhs,
                           AcirFormatOriginalOpcodeIndices const& rhs) = default;
};
 
struct AcirFormat {
    uint32_t max_witness_index = 0;
    uint32_t num_acir_opcodes;
 
    std::vector<uint32_t> public_inputs;
 
    std::vector<LogicConstraint> logic_constraints;
    std::vector<RangeConstraint> range_constraints;
    std::vector<AES128Constraint> aes128_constraints;
    std::vector<Sha256Compression> sha256_compression;
    std::vector<EcdsaConstraint> ecdsa_k1_constraints;
    std::vector<EcdsaConstraint> ecdsa_r1_constraints;
    std::vector<Blake2sConstraint> blake2s_constraints;
    std::vector<Blake3Constraint> blake3_constraints;
    std::vector<Keccakf1600> keccak_permutations;
    std::vector<Poseidon2Constraint> poseidon2_constraints;
    std::vector<MultiScalarMul> multi_scalar_mul_constraints;
    std::vector<EcAdd> ec_add_constraints;
    std::vector<RecursionConstraint> honk_recursion_constraints;
    std::vector<RecursionConstraint> avm_recursion_constraints;
    std::vector<RecursionConstraint> hn_recursion_constraints;
    std::vector<RecursionConstraint> chonk_recursion_constraints;
    std::vector<QuadConstraint> quad_constraints;
    std::vector<BigQuadConstraint> big_quad_constraints;
    std::vector<BilinearConstraint> bilinear_constraints;
    std::vector<BatchedEqCheckConstraint> batched_eq_check_constraints;
    std::vector<BlockConstraint> block_constraints;
 
    // Number of gates added to the circuit per original opcode.
    // Has length equal to num_acir_opcodes.
    std::vector<size_t> gates_per_opcode;
 
    // Indices of the original opcode that originated each constraint in AcirFormat.
    AcirFormatOriginalOpcodeIndices original_opcode_indices;
 
    friend bool operator==(AcirFormat const& lhs, AcirFormat const& rhs) = default;
};
 
struct AcirProgram {
    AcirFormat constraints;
    WitnessVector witness;
};
 
struct ProgramMetadata {
    // An IVC instance; needed to construct a circuit from IVC recursion constraints
    std::shared_ptr<bb::Chonk> ivc = nullptr;
 
    bool has_ipa_claim =
        false; // Boolean describing whether the circuit should propagate an IPA claim or not. If `True`, the circuit
               // should propagate an IPA claim. In our codebase, circuits that propagate IPA claims are the ones whose
               // proof is constructed/verified using Rollup flavors.
    bool collect_gates_per_opcode = false;
};
 
template <typename Builder>
Builder create_circuit(AcirProgram& program, const ProgramMetadata& metadata = ProgramMetadata{});
 
template <typename Builder>
void build_constraints(Builder& builder, AcirFormat& constraints, const ProgramMetadata& metadata);
 
} // namespace acir_format