mega_circuit_builder.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 <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();
 
  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);
    void apply_databus_selectors(BusId bus_idx);
 
  public:
    MegaCircuitBuilder_(const size_t size_hint = 0,
                        std::shared_ptr<ECCOpQueue> op_queue_in = std::make_shared<ECCOpQueue>())
        : UltraCircuitBuilder_<MegaExecutionTraceBlocks>(size_hint)
        , 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)
        : MegaCircuitBuilder_(0, op_queue_in)
    {}
 
    MegaCircuitBuilder_(std::shared_ptr<ECCOpQueue> op_queue_in,
                        auto& witness_values,
                        const std::vector<uint32_t>& public_inputs,
                        size_t varnum)
        : UltraCircuitBuilder_<MegaExecutionTraceBlocks>(/*size_hint=*/0, witness_values, public_inputs, varnum)
        , 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(const bool ensure_nonzero);
    void add_ultra_and_mega_gates_to_ensure_all_polys_are_non_zero();
    void add_mega_gates_to_ensure_all_polys_are_non_zero();
 
    size_t get_num_constant_gates() const override { return 0; }
 
    size_t get_estimated_num_finalized_gates() const override
    {
        auto num_ultra_gates = UltraCircuitBuilder_<MegaExecutionTraceBlocks>::get_estimated_num_finalized_gates();
        auto num_goblin_ecc_op_gates = this->blocks.ecc_op.size();
        return num_ultra_gates + num_goblin_ecc_op_gates;
    }
 
    void print_num_estimated_finalized_gates() const override
    {
        size_t count = 0;
        size_t rangecount = 0;
        size_t romcount = 0;
        size_t ramcount = 0;
        size_t nnfcount = 0;
        UltraCircuitBuilder_<MegaExecutionTraceBlocks>::get_num_estimated_gates_split_into_components(
            count, rangecount, romcount, ramcount, nnfcount);
        auto num_goblin_ecc_op_gates = this->blocks.ecc_op.size();
 
        size_t total = count + romcount + ramcount + rangecount + num_goblin_ecc_op_gates;
        std::cout << "gates = " << total << " (arith " << count << ", rom " << romcount << ", ram " << ramcount
                  << ", range " << rangecount << ", non native field gates " << nnfcount << ", goblin ecc op gates "
                  << num_goblin_ecc_op_gates << "), pubinp = " << this->num_public_inputs() << std::endl;
    }
 
    void add_public_calldata(const uint32_t& in) { return append_to_bus_vector(BusId::CALLDATA, in); }
 
    void add_public_secondary_calldata(const uint32_t& in)
    {
        return append_to_bus_vector(BusId::SECONDARY_CALLDATA, 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);
 
    uint32_t read_calldata(const uint32_t& read_idx_witness_idx)
    {
        return read_bus_vector(BusId::CALLDATA, read_idx_witness_idx);
    };
 
    uint32_t read_secondary_calldata(const uint32_t& read_idx_witness_idx)
    {
        return read_bus_vector(BusId::SECONDARY_CALLDATA, 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)
    {
        databus[static_cast<size_t>(bus_idx)].append(witness_idx);
    }
 
    const BusVector& get_calldata() const { return databus[static_cast<size_t>(BusId::CALLDATA)]; }
    const BusVector& get_secondary_calldata() const { return databus[static_cast<size_t>(BusId::SECONDARY_CALLDATA)]; }
    const BusVector& get_return_data() const { return databus[static_cast<size_t>(BusId::RETURNDATA)]; }
 
    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