mega_circuit_builder.cpp

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: }
// =====================
 
#include "mega_circuit_builder.hpp"
#include "barretenberg/common/assert.hpp"
#include "barretenberg/crypto/poseidon2/poseidon2_params.hpp"
#include "barretenberg/flavor/mega_flavor.hpp"
#include <array>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
 
using namespace bb;
using namespace bb::crypto;
 
namespace bb {
 
template <typename FF> void MegaCircuitBuilder_<FF>::finalize_circuit()
{
    UltraCircuitBuilder_<MegaExecutionTraceBlocks>::finalize_circuit();
}
 
template <typename FF> ecc_op_tuple MegaCircuitBuilder_<FF>::queue_ecc_add_accum(const bb::g1::affine_element& point)
{
    // Add the operation to the op queue
    auto ultra_op = op_queue->add_accumulate(point);
 
    // Add corresponding gates for the operation
    ecc_op_tuple op_tuple = populate_ecc_op_wires(ultra_op);
    return op_tuple;
}
 
template <typename FF>
ecc_op_tuple MegaCircuitBuilder_<FF>::queue_ecc_mul_accum(const bb::g1::affine_element& point,
                                                          const FF& scalar,
                                                          bool in_finalize)
{
    // Add the operation to the op queue
    auto ultra_op = op_queue->mul_accumulate(point, scalar);
 
    // Add corresponding gates for the operation
    ecc_op_tuple op_tuple = populate_ecc_op_wires(ultra_op, in_finalize);
    return op_tuple;
}
 
template <typename FF> ecc_op_tuple MegaCircuitBuilder_<FF>::queue_ecc_eq(bool in_finalize)
{
    // Add the operation to the op queue
    auto ultra_op = op_queue->eq_and_reset();
 
    // Add corresponding gates for the operation
    ecc_op_tuple op_tuple = populate_ecc_op_wires(ultra_op, in_finalize);
    op_tuple.return_is_infinity = ultra_op.return_is_infinity;
    return op_tuple;
}
 
template <typename FF> ecc_op_tuple MegaCircuitBuilder_<FF>::queue_ecc_no_op()
{
    // Add the operation to the op queue
    auto ultra_op = op_queue->no_op_ultra_only();
 
    // Add corresponding gates for the operation
    ecc_op_tuple op_tuple = populate_ecc_op_wires(ultra_op);
    return op_tuple;
}
 
template <typename FF>
ecc_op_tuple MegaCircuitBuilder_<FF>::populate_ecc_op_wires(const UltraOp& ultra_op, bool in_finalize)
{
    ecc_op_tuple op_tuple;
    op_tuple.op = get_ecc_op_idx(ultra_op.op_code);
    op_tuple.x_lo = this->add_variable(ultra_op.x_lo);
    op_tuple.x_hi = this->add_variable(ultra_op.x_hi);
    op_tuple.y_lo = this->add_variable(ultra_op.y_lo);
    op_tuple.y_hi = this->add_variable(ultra_op.y_hi);
    op_tuple.z_1 = this->add_variable(ultra_op.z_1);
    op_tuple.z_2 = this->add_variable(ultra_op.z_2);
 
    // Set the indices for the op values for each of the two rows
    uint32_t op_val_idx_1 = op_tuple.op;      // genuine op code value
    uint32_t op_val_idx_2 = this->zero_idx(); // second row value always set to 0
    // If this is a random operation, the op values are randomized
    if (ultra_op.op_code.is_random_op) {
        op_val_idx_1 = this->add_variable(ultra_op.op_code.random_value_1);
        op_val_idx_2 = this->add_variable(ultra_op.op_code.random_value_2);
    }
    // Populate the ecc_op block with TWO rows (matching Ultra format)
    // Row 1: OP   | x_lo | x_hi | y_lo
    // Row 2: 0    | y_hi | z_1  | z_2
    this->blocks.ecc_op.append_gate({ .wires = { op_val_idx_1, op_tuple.x_lo, op_tuple.x_hi, op_tuple.y_lo } });
    this->blocks.ecc_op.append_gate({ .wires = { op_val_idx_2, op_tuple.y_hi, op_tuple.z_1, op_tuple.z_2 } });
 
    if (in_finalize) {
        update_used_witnesses(
            { op_tuple.op, op_tuple.x_lo, op_tuple.x_hi, op_tuple.y_lo, op_tuple.y_hi, op_tuple.z_1, op_tuple.z_2 });
        update_finalize_witnesses(
            { op_tuple.op, op_tuple.x_lo, op_tuple.x_hi, op_tuple.y_lo, op_tuple.y_hi, op_tuple.z_1, op_tuple.z_2 });
    }
 
    return op_tuple;
};
 
template <typename FF> void MegaCircuitBuilder_<FF>::queue_ecc_random_op()
{
    // Add the operation to the op queue
    auto ultra_op = op_queue->random_op_ultra_only();
 
    // Add corresponding gates for the operation
    (void)populate_ecc_op_wires(ultra_op);
}
 
template <typename FF>
void MegaCircuitBuilder_<FF>::queue_ecc_hiding_op(const curve::BN254::BaseField& Px, const curve::BN254::BaseField& Py)
{
    // Add the operation to the op queue (returns the UltraOp for gate creation)
    auto ultra_op = op_queue->append_hiding_op(Px, Py);
 
    // Add corresponding gates for the operation
    populate_ecc_op_wires(ultra_op);
}
 
template <typename FF> void MegaCircuitBuilder_<FF>::set_goblin_ecc_op_code_constant_variables()
{
    null_op_idx = this->zero_idx(); // constant 0 is is associated with the zero index
    add_accum_op_idx = this->put_constant_variable(FF(EccOpCode{ .add = true }.value()));
    mul_accum_op_idx = this->put_constant_variable(FF(EccOpCode{ .mul = true }.value()));
    equality_op_idx = this->put_constant_variable(FF(EccOpCode{ .eq = true, .reset = true }.value()));
}
 
template <typename FF>
uint32_t MegaCircuitBuilder_<FF>::read_bus_vector(BusId bus_idx, const uint32_t& read_idx_witness_idx)
{
    auto& bus_vector = databus[static_cast<size_t>(bus_idx)];
    // Get the raw index into the databus column
    const uint32_t read_idx = static_cast<uint32_t>(uint256_t(this->get_variable(read_idx_witness_idx)));
 
    BB_ASSERT_LT(read_idx, bus_vector.size()); // Ensure that the read index is valid
 
    // Create a variable corresponding to the result of the read. Note that we do not in general connect reads from
    // databus via copy constraints (i.e. we create a unique variable for the result of each read)
    FF value = this->get_variable(bus_vector[read_idx]);
    uint32_t value_witness_idx = this->add_variable(value);
 
    create_databus_read_gate({ read_idx_witness_idx, value_witness_idx }, bus_idx);
    bus_vector.increment_read_count(read_idx);
 
    return value_witness_idx;
}
 
template <typename FF> void MegaCircuitBuilder_<FF>::create_databus_init_read_gate(BusId bus_idx, size_t slot_idx)
{
    auto& bus_vector = databus[static_cast<size_t>(bus_idx)];
    BB_ASSERT_LT(slot_idx, bus_vector.size());
 
    const uint32_t value_witness_idx = bus_vector[slot_idx];
    const uint32_t index_witness_idx = this->put_constant_variable(FF(static_cast<uint64_t>(slot_idx)));
 
    create_databus_read_gate({ index_witness_idx, value_witness_idx }, bus_idx);
    bus_vector.increment_read_count(slot_idx);
}
 
template <typename FF>
void MegaCircuitBuilder_<FF>::create_databus_read_gate(const databus_lookup_gate_<FF>& in, const BusId bus_idx)
{
    auto& block = this->blocks.busread;
    GateRowT row{};
    row.wires = { in.value, in.index, this->zero_idx(), this->zero_idx() };
    // Bus column k (0 <= k < NUM_BUS_COLUMNS) is selected by one of these selectors. The order here
    // must match BusData<bus_idx>::selector in databus_lookup_relation.hpp and the bus selector
    // order in flavor-codegen mega.ts / mega_kernel.ts.
    const std::array<FF*, NUM_BUS_COLUMNS> databus_selectors{ &row.q_1, &row.q_2, &row.q_3, &row.q_4,
                                                              &row.q_5, &row.q_c, &row.q_m };
    const size_t idx = static_cast<size_t>(bus_idx);
    BB_ASSERT_LT(idx, databus_selectors.size());
    *databus_selectors[idx] = 1;
    row.gate_kind = GateKind::BusRead;
    row.gate_value = 1;
    block.append_gate(row);
    this->increment_num_gates();
}
 
template <typename FF>
void MegaCircuitBuilder_<FF>::create_poseidon2_external_gate(const poseidon2_external_gate_<FF>& in)
{
    auto& block = this->blocks.poseidon2;
    block.append_gate({ .wires = { in.a, in.b, in.c, in.d },
                        .q_1 = crypto::Poseidon2Bn254ScalarFieldParams::round_constants[in.round_idx][0],
                        .q_2 = crypto::Poseidon2Bn254ScalarFieldParams::round_constants[in.round_idx][1],
                        .q_3 = crypto::Poseidon2Bn254ScalarFieldParams::round_constants[in.round_idx][2],
                        .q_4 = crypto::Poseidon2Bn254ScalarFieldParams::round_constants[in.round_idx][3],
                        .gate_kind = GateKind::Poseidon2Ext,
                        .gate_value = 1 });
    this->increment_num_gates();
}
 
template <typename FF>
void MegaCircuitBuilder_<FF>::create_poseidon2_initial_external_gate(const poseidon2_initial_external_gate_<FF>& in)
{
    auto& block = this->blocks.poseidon2;
    block.append_gate(
        { .wires = { in.a, in.b, in.c, in.d }, .gate_kind = GateKind::Poseidon2ExtInitial, .gate_value = 1 });
    this->increment_num_gates();
}
 
template <typename FF>
void MegaCircuitBuilder_<FF>::create_poseidon2_quad_internal_gate(const poseidon2_quad_internal_gate_<FF>& in)
{
    auto& block = this->blocks.poseidon2;
    const auto& rc = crypto::Poseidon2Bn254ScalarFieldParams::round_constants;
    {
        auto& block_for_row = block;
        GateRowT row{};
        row.wires = { in.a, in.b, in.c, in.d };
        row.q_1 = rc[in.round_idx_start + 0][0];
        row.q_2 = rc[in.round_idx_start + 1][0];
        row.q_3 = rc[in.round_idx_start + 2][0];
        row.q_4 = rc[in.round_idx_start + 3][0];
        if (in.is_terminal) {
            row.gate_kind = GateKind::Poseidon2QuadIntTerminal;
            row.gate_value = 1;
        } else {
            row.q_m = rc[in.next_pair_start + 0][0];
            row.q_c = rc[in.next_pair_start + 1][0];
            row.q_5 = rc[in.next_pair_start + 2][0];
            row.gate_kind = GateKind::Poseidon2QuadInt;
            row.gate_value = 1;
        }
        block_for_row.append_gate(row);
    }
    this->increment_num_gates();
}
 
template <typename FF>
void MegaCircuitBuilder_<FF>::create_poseidon2_transition_entry_gate(const poseidon2_transition_entry_gate_<FF>& in)
{
    auto& block = this->blocks.poseidon2;
    const auto& rc = crypto::Poseidon2Bn254ScalarFieldParams::round_constants;
    block.append_gate({ .wires = { in.a, in.b, in.c, in.d },
                        .q_1 = rc[in.round_idx_start + 0][0],
                        .q_2 = rc[in.round_idx_start + 1][0],
                        .q_3 = rc[in.round_idx_start + 2][0],
                        .gate_kind = GateKind::Poseidon2TransitionEntry,
                        .gate_value = 1 });
    this->increment_num_gates();
}
 
template class MegaCircuitBuilder_<bb::fr>;
} // namespace bb