acir_format.hpp

Go to the documentation of this file.

// === AUDIT STATUS ===
// internal:    { status: not started, auditors: [], date: YYYY-MM-DD }
// external_1:  { status: not started, auditors: [], date: YYYY-MM-DD }
// external_2:  { status: not started, auditors: [], date: YYYY-MM-DD }
// =====================
 
#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 "barretenberg/serialize/msgpack.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 <cstdint>
#include <utility>
#include <vector>
 
namespace acir_format {
 
using QuadConstraints = mul_quad_<fr>;
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> arithmetic_triple_constraints;
    std::vector<size_t> quad_constraints;
    std::vector<size_t> big_quad_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<QuadConstraints> quad_constraints; // Standard honk arithmetic constraint of width 4
    // A vector of vector of mul_quad gates (i.e arithmetic constraints of width 4)
    // Each vector of gates represente a 'big' expression (a polynomial of degree 1 or 2 which does not fit inside one
    // mul_gate) that has been splitted into multiple mul_gates, using w4_shift (the 4th wire of the next gate), to
    // reduce the number of intermediate variables.
    std::vector<std::vector<QuadConstraints>> big_quad_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;
 
    // For serialization, update with any new fields
    MSGPACK_FIELDS(public_inputs,
                   logic_constraints,
                   range_constraints,
                   aes128_constraints,
                   sha256_compression,
                   ecdsa_k1_constraints,
                   ecdsa_r1_constraints,
                   blake2s_constraints,
                   blake3_constraints,
                   keccak_permutations,
                   poseidon2_constraints,
                   multi_scalar_mul_constraints,
                   ec_add_constraints,
                   honk_recursion_constraints,
                   avm_recursion_constraints,
                   hn_recursion_constraints,
                   chonk_recursion_constraints,
                   quad_constraints,
                   big_quad_constraints,
                   block_constraints);
 
    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::IVCBase> 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;
    size_t size_hint = 0;
};
 
// TODO(https://github.com/AztecProtocol/barretenberg/issues/1161) Refactor this function
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);
 
template <typename Builder> class GateCounter {
  public:
    GateCounter(Builder* builder, bool collect_gates_per_opcode)
        : builder(builder)
        , collect_gates_per_opcode(collect_gates_per_opcode)
    {}
 
    size_t compute_diff()
    {
        if (!collect_gates_per_opcode) {
            return 0;
        }
        size_t new_gate_count = builder->get_num_finalized_gates_inefficient(/*ensure_nonzero=*/false);
        size_t diff = new_gate_count - prev_gate_count;
        prev_gate_count = new_gate_count;
        return diff;
    }
 
    void track_diff(std::vector<size_t>& gates_per_opcode, size_t opcode_index)
    {
        if (collect_gates_per_opcode) {
            gates_per_opcode[opcode_index] = compute_diff();
        }
    }
 
  private:
    Builder* builder;
    bool collect_gates_per_opcode;
    size_t prev_gate_count{};
};
} // namespace acir_format