mock_circuit_producer.hpp

Go to the documentation of this file.

#pragma once
 
#include "barretenberg/chonk/chonk.hpp"
#include "barretenberg/common/bb_bench.hpp"
#include "barretenberg/goblin/mock_circuits.hpp"
#include "barretenberg/stdlib_circuit_builders/ultra_circuit_builder.hpp"
#include "barretenberg/ultra_honk/ultra_verifier.hpp"
 
using namespace bb;
 
namespace {
 
class MockDatabusProducer {
  private:
    using ClientCircuit = Chonk::ClientCircuit;
    using Flavor = MegaFlavor;
    using FF = Flavor::FF;
    using BusDataArray = std::vector<FF>;
 
    static constexpr size_t BUS_ARRAY_SIZE = 3; // arbitrary length of mock bus inputs
    std::array<BusDataArray, MAX_APPS_PER_KERNEL> app_return_data;
    BusDataArray kernel_return_data;
 
    FF dummy_return_val = 1; // use simple return val for easier test debugging
 
    BusDataArray generate_random_bus_array()
    {
        BusDataArray result;
        for (size_t i = 0; i < BUS_ARRAY_SIZE; ++i) {
            result.emplace_back(dummy_return_val);
        }
        dummy_return_val += 1;
        return result;
    }
 
  public:
    void populate_app_databus(ClientCircuit& circuit)
    {
        for (auto& app_data : app_return_data) {
            if (app_data.empty()) {
                app_data = generate_random_bus_array();
                for (auto& val : app_data) {
                    circuit.add_public_return_data(circuit.add_variable(val));
                }
                return;
            }
        }
    };
 
    void populate_kernel_databus(ClientCircuit& circuit)
    {
        // Populate kernel calldata from previous kernel return data (if it exists)
        for (auto& val : kernel_return_data) {
            circuit.add_public_calldata(BusId::KERNEL_CALLDATA, circuit.add_variable(val));
        }
        // Populate app calldata from app return data (if it exists), then clear the app return data
        for (size_t idx = 0; idx < app_return_data.size(); ++idx) {
            for (auto& val : app_return_data[idx]) {
                circuit.add_public_calldata(static_cast<BusId>(idx + 1), circuit.add_variable(val));
            }
            app_return_data[idx].clear();
        }
 
        // Mock the return data for the present kernel circuit
        kernel_return_data = generate_random_bus_array();
        for (auto& val : kernel_return_data) {
            circuit.add_public_return_data(circuit.add_variable(val));
        }
    };
};
 
struct TestSettings {
    // number of public inputs to manually add to circuits, by default this would be 0 because we use the
    // MockDatabusProducer to test public inputs handling
    size_t num_public_inputs = 0;
    // by default we will create more complex apps and kernel with various types of gates but in case we want to
    // specifically test overflow behaviour or unstructured circuits we can manually construct simple circuits with a
    // specified number of gates
    size_t log2_num_gates = 0;
};
 
class PrivateFunctionExecutionMockCircuitProducer {
    using ClientCircuit = Chonk::ClientCircuit;
    using Flavor = MegaFlavor;
    using VerificationKey = Flavor::VerificationKey;
 
    size_t circuit_counter = 0;
    std::vector<bool> is_kernel_flags;
 
    MockDatabusProducer mock_databus;
    bool large_first_app = true;
    constexpr static size_t NUM_TRAILING_KERNELS = 3; // reset, tail, hiding
 
  public:
    size_t total_num_circuits = 0;
 
    PrivateFunctionExecutionMockCircuitProducer(size_t num_app_circuits, bool large_first_app = true)
        : large_first_app(large_first_app)
    {
        for (size_t i = 0; i < num_app_circuits / MAX_APPS_PER_KERNEL; ++i) {
            for (size_t idx = 0; idx < MAX_APPS_PER_KERNEL; ++idx) {
                is_kernel_flags.emplace_back(false);
            }
            is_kernel_flags.emplace_back(true);
        }
        if (num_app_circuits % MAX_APPS_PER_KERNEL != 0) {
            for (size_t idx = 0; idx < num_app_circuits % MAX_APPS_PER_KERNEL; ++idx) {
                is_kernel_flags.emplace_back(false);
            }
            is_kernel_flags.emplace_back(true);
        }
        for (size_t i = 0; i < NUM_TRAILING_KERNELS; ++i) {
            is_kernel_flags.emplace_back(true);
        }
        total_num_circuits = is_kernel_flags.size();
    }
 
    PrivateFunctionExecutionMockCircuitProducer(std::vector<bool> leading_is_kernel_flags, bool large_first_app = false)
        : is_kernel_flags(std::move(leading_is_kernel_flags))
        , large_first_app(large_first_app)
    {
        BB_ASSERT(!is_kernel_flags.empty(), "Mock circuit layout must contain at least one leading circuit");
        BB_ASSERT_EQ(is_kernel_flags[0], false, "Mock circuit layout must start with an app circuit");
        for (size_t i = 0; i < NUM_TRAILING_KERNELS; ++i) {
            is_kernel_flags.emplace_back(true);
        }
        total_num_circuits = is_kernel_flags.size();
    }
 
    static std::shared_ptr<VerificationKey> get_verification_key(ClientCircuit& builder_in,
                                                                 bool is_hiding_kernel = false)
    {
        // This is a workaround to ensure that the circuit is finalized before we create the verification key
        // In practice, this should not be needed as the circuit will be finalized when it is accumulated into the IVC
        // but this is a workaround for the test setup.
        MegaCircuitBuilder_<bb::fr> builder{ builder_in };
 
        // Deepcopy the opqueue to avoid modifying the original one when finalising the circuit
        builder.op_queue = std::make_shared<ECCOpQueue>(*builder.op_queue);
 
        if (is_hiding_kernel) {
            auto prover_instance = std::make_shared<Chonk::HidingKernelProverInstance>(builder);
            return std::make_shared<VerificationKey>(prover_instance->get_precomputed());
        }
        auto prover_instance = std::make_shared<Chonk::ProverInstance>(builder);
        return std::make_shared<VerificationKey>(prover_instance->get_precomputed());
    }
 
    ClientCircuit create_next_circuit(Chonk& ivc,
                                      size_t log2_num_gates = 0,
                                      size_t num_public_inputs = 0,
                                      bool check_circuit_sizes = false)
    {
        const bool is_kernel = is_kernel_flags[circuit_counter++];
        const bool use_large_circuit = large_first_app && (circuit_counter == 1); // first circuit is size 2^19
        // Check if this is one of the trailing kernels (reset, tail, hiding)
        const bool is_trailing_kernel = (ivc.num_circuits_accumulated >= ivc.get_num_circuits() - NUM_TRAILING_KERNELS);
 
        ClientCircuit circuit{ ivc.goblin.op_queue };
        // if the number of gates is specified we just add a number of arithmetic gates
        if (log2_num_gates != 0) {
            MockCircuits::construct_arithmetic_circuit(circuit, log2_num_gates, /* include_public_inputs= */ false);
            // Add some public inputs
            for (size_t i = 0; i < num_public_inputs; ++i) {
                circuit.add_public_variable(typename Flavor::FF(13634816 + i)); // arbitrary number
            }
        } else {
            // If the number of gates is not specified we create a structured mock circuit
            if (is_kernel) {
                // For trailing kernels (reset, tail, hiding), skip the expensive mock kernel logic to match real Noir
                // flows. These kernels are simpler and mainly contain the completion logic added by Chonk.
                if (!is_trailing_kernel) {
                    GoblinMockCircuits::construct_mock_folding_kernel(circuit); // construct mock base logic
                }
                mock_databus.populate_kernel_databus(circuit); // populate databus inputs/outputs
            } else {
                GoblinMockCircuits::construct_mock_app_circuit(circuit, use_large_circuit); // construct mock app
                mock_databus.populate_app_databus(circuit);                                 // populate databus outputs
            }
        }
 
        if (is_kernel) {
            ivc.complete_kernel_circuit_logic(circuit);
        } else {
            stdlib::recursion::honk::AppIO::add_default(circuit);
        }
 
        if (check_circuit_sizes) {
            auto prover_instance = std::make_shared<Chonk::ProverInstance>(circuit);
            size_t log2_dyadic_size = prover_instance->log_dyadic_size();
            if (log2_num_gates != 0) {
                if (is_kernel) {
                    // There are various possibilities here, so we provide a bound
                    BB_ASSERT_LTE(
                        log2_dyadic_size,
                        19UL,
                        "Log number of gates in a kernel with fixed number of arithmetic gates has exceeded bound.");
                    vinfo("Log number of gates in a kernel with fixed number of arithmetic gates is: ",
                          log2_dyadic_size);
                } else {
                    // The offset is due to the fact that finalization adds a certain number of gates
                    size_t LOG2_OFFSET = 2;
                    BB_ASSERT_LTE(log2_dyadic_size,
                                  log2_num_gates + LOG2_OFFSET,
                                  "Log number of arithemtic gates produced is different from the one requested.");
                }
            } else {
                if (is_kernel) {
                    // Trailing kernels (reset, tail, hiding) are simpler than regular kernels
                    if (is_trailing_kernel) {
                        // Trailing kernels should be significantly smaller, with hiding kernel < 2^16
                        BB_ASSERT_LTE(log2_dyadic_size,
                                      17UL,
                                      "Trailing kernel circuit size has exceeded expected bound (should be <= 2^16).");
                        vinfo("Log number of gates in a trailing kernel circuit is: ", log2_dyadic_size);
                    } else {
                        const bool is_init_kernel = circuit_counter == 2;
                        const size_t expected_log2_dyadic_size = is_init_kernel ? 17UL : 18UL;
                        BB_ASSERT_EQ(log2_dyadic_size,
                                     expected_log2_dyadic_size,
                                     "There has been a change in the number of gates of a mock kernel circuit.");
                    }
                } else {
                    BB_ASSERT_EQ(log2_dyadic_size,
                                 use_large_circuit ? 19UL : 17UL,
                                 "There has been a change in the of gates generated for a mock app circuit.");
                }
            }
        }
        return circuit;
    }
 
    std::pair<ClientCircuit, std::shared_ptr<VerificationKey>> create_next_circuit_and_vk(
        Chonk& ivc, TestSettings settings = {}, bool check_circuit_size = false)
    {
        // If this is a mock hiding kernel, remove the settings and use a default (non-structured) trace
        const bool is_hiding_kernel = ivc.num_circuits_accumulated == ivc.get_num_circuits() - 1;
        if (is_hiding_kernel) {
            settings = TestSettings{};
        }
        auto circuit =
            create_next_circuit(ivc, settings.log2_num_gates, settings.num_public_inputs, check_circuit_size);
        return { circuit, get_verification_key(circuit, is_hiding_kernel) };
    }
 
    void construct_and_accumulate_next_circuit(Chonk& ivc, TestSettings settings = {}, bool check_circuit_sizes = false)
    {
        auto [circuit, vk] = create_next_circuit_and_vk(ivc, settings, check_circuit_sizes);
        ivc.accumulate(circuit, vk);
    }
};
 
} // namespace