mega_circuit_builder.hpp

Go to the documentation of this file.

// === AUDIT STATUS ===
// internal:    { status: Complete, auditors: [Luke, Raju], commit: }
// external_1:  { status: not started, auditors: [], commit: }
// external_2:  { status: not started, auditors: [], commit: }
// =====================
 
#pragma once
#include <sstream>
#include <utility>
 
#include "barretenberg/crypto/sha256/sha256.hpp"
#include "barretenberg/honk/execution_trace/mega_execution_trace.hpp"
#include "barretenberg/op_queue/ecc_op_queue.hpp"
#include "databus.hpp"
#include "ultra_circuit_builder.hpp"
 
namespace bb {
 
template <typename FF> class MegaCircuitBuilder_ : public UltraCircuitBuilder_<MegaExecutionTraceBlocks> {
  private:
    DataBus databus; // Container for public calldata/returndata
 
  public:
    using ExecutionTrace = MegaExecutionTraceBlocks;
 
    static constexpr size_t DEFAULT_NON_NATIVE_FIELD_LIMB_BITS =
        UltraCircuitBuilder_<MegaExecutionTraceBlocks>::DEFAULT_NON_NATIVE_FIELD_LIMB_BITS;
 
    // Stores record of ecc operations and performs corresponding native operations internally
    std::shared_ptr<ECCOpQueue> op_queue;
 
    // Indices for constant variables corresponding to ECCOpQueue op codes
    uint32_t null_op_idx;
    uint32_t add_accum_op_idx;
    uint32_t mul_accum_op_idx;
    uint32_t equality_op_idx;
 
    // Functions for adding ECC op queue "gates"
    ecc_op_tuple queue_ecc_add_accum(const g1::affine_element& point);
    ecc_op_tuple queue_ecc_mul_accum(const g1::affine_element& point, const FF& scalar, bool in_finalize = false);
    ecc_op_tuple queue_ecc_eq(bool in_finalize = true);
    ecc_op_tuple queue_ecc_no_op();
    void queue_ecc_random_op();
    void queue_ecc_hiding_op(const curve::BN254::BaseField& Px, const curve::BN254::BaseField& Py);
 
  private:
    ecc_op_tuple populate_ecc_op_wires(const UltraOp& ultra_op, bool in_finalize = false);
    void set_goblin_ecc_op_code_constant_variables();
    void create_databus_read_gate(const databus_lookup_gate_<FF>& in, BusId bus_idx);
 
  public:
    MegaCircuitBuilder_(std::shared_ptr<ECCOpQueue> op_queue_in = std::make_shared<ECCOpQueue>(),
                        bool is_write_vk_mode = false)
        : UltraCircuitBuilder_<MegaExecutionTraceBlocks>(is_write_vk_mode)
        , op_queue(std::move(op_queue_in))
    {
        BB_BENCH();
        // Instantiate the subtable to be populated with goblin ecc ops from this circuit. The merge settings indicate
        // whether the subtable should be prepended or appended to the existing subtables from prior circuits.
        op_queue->initialize_new_subtable();
 
        // Set indices to constants corresponding to Goblin ECC op codes
        set_goblin_ecc_op_code_constant_variables();
    };
 
    MegaCircuitBuilder_(std::shared_ptr<ECCOpQueue> op_queue_in,
                        const std::vector<FF>& witness_values,
                        const std::vector<uint32_t>& public_inputs,
                        const bool is_write_vk_mode)
        : UltraCircuitBuilder_<MegaExecutionTraceBlocks>(witness_values, public_inputs, is_write_vk_mode)
        , op_queue(std::move(op_queue_in))
    {
        // Instantiate the subtable to be populated with goblin ecc ops from this circuit. The merge settings indicate
        // whether the subtable should be prepended or appended to the existing subtables from prior circuits.
        op_queue->initialize_new_subtable();
 
        // Set indices to constants corresponding to Goblin ECC op codes
        set_goblin_ecc_op_code_constant_variables();
    };
 
    uint32_t get_ecc_op_idx(const EccOpCode& op_code)
    {
        if (op_code.add) {
            return add_accum_op_idx;
        }
        if (op_code.mul) {
            return mul_accum_op_idx;
        }
        if (op_code.eq && op_code.reset) {
            return equality_op_idx;
        }
        if (!op_code.add && !op_code.mul && !op_code.eq && !op_code.reset) {
            return null_op_idx;
        }
 
        throw_or_abort("Invalid op code");
        return 0;
    }
 
    void finalize_circuit();
 
    // Shadows UltraCircuitBuilder_::create_poseidon2_external_gate so Mega external rounds land in the
    // shared `poseidon2` block alongside the internal rounds (keeping each permutation's rows contiguous).
    void create_poseidon2_external_gate(const poseidon2_external_gate_<FF>& in);
    void create_poseidon2_initial_external_gate(const poseidon2_initial_external_gate_<FF>& in);
    void create_poseidon2_quad_internal_gate(const poseidon2_quad_internal_gate_<FF>& in);
    void create_poseidon2_transition_entry_gate(const poseidon2_transition_entry_gate_<FF>& in);
 
    size_t get_num_constant_gates() const override { return 0; }
 
    void add_public_calldata(BusId bus_idx, const uint32_t& in) { return append_to_bus_vector(bus_idx, in); }
 
    void add_public_return_data(const uint32_t& in) { return append_to_bus_vector(BusId::RETURNDATA, in); }
 
    uint32_t read_bus_vector(BusId bus_idx, const uint32_t& read_idx_witness_idx);
 
    void create_databus_init_read_gate(BusId bus_idx, size_t slot_idx);
 
    uint32_t read_calldata(BusId bus_idx, const uint32_t& read_idx_witness_idx)
    {
        return read_bus_vector(bus_idx, read_idx_witness_idx);
    };
 
    uint32_t read_return_data(const uint32_t& read_idx_witness_idx)
    {
        return read_bus_vector(BusId::RETURNDATA, read_idx_witness_idx);
    };
 
    void append_to_bus_vector(const BusId bus_idx, const uint32_t& witness_idx)
    {
        auto& bus_vector = databus[static_cast<size_t>(bus_idx)];
        bus_vector.append(witness_idx);
        create_databus_init_read_gate(bus_idx, bus_vector.size() - 1);
    }
 
    const BusVector& get_calldata(BusId idx) const { return databus[static_cast<size_t>(idx)]; }
    const BusVector& get_return_data() const { return databus[static_cast<size_t>(BusId::RETURNDATA)]; }
    // Indexed access to the databus columns; enables NUM_BUS_COLUMNS-driven iteration over bus vectors.
    const BusVector& get_bus_vector(size_t bus_idx) const { return databus[bus_idx]; }
 
    std::string hash() const
    {
        using serialize::write;
        std::vector<uint8_t> buffer;
 
        // Hash each block's complete structure - need to const_cast to call non-const methods
        auto& blocks_ref = const_cast<MegaExecutionTraceBlocks&>(this->blocks);
        for (auto& block : blocks_ref.get()) {
            // Hash all wires; implicitly contains copy constraint information
            for (const auto& wire : block.wires) {
                for (const auto& idx : wire) {
                    write(buffer, idx);
                }
            }
 
            // Hash all selectors
            auto selectors = block.get_selectors();
            for (auto& selector : selectors) {
                for (size_t i = 0; i < selector.size(); ++i) {
                    write(buffer, selector[i]);
                }
            }
        }
 
        // Compute SHA256 hash
        auto hash_bytes = crypto::sha256(buffer);
 
        // Convert to hex string
        std::stringstream ss;
        ss << hash_bytes;
        return ss.str();
    }
};
using MegaCircuitBuilder = MegaCircuitBuilder_<bb::fr>;
} // namespace bb