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
    BusDataArray 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)
    {
        app_return_data = generate_random_bus_array();
        for (auto& val : app_return_data) {
            circuit.add_public_return_data(circuit.add_variable(val));
        }
    };
 
    void populate_kernel_databus(ClientCircuit& circuit)
    {
        // Populate calldata from previous kernel return data (if it exists)
        for (auto& val : kernel_return_data) {
            circuit.add_public_calldata(circuit.add_variable(val));
        }
        // Populate secondary_calldata from app return data (if it exists), then clear the app return data
        for (auto& val : app_return_data) {
            circuit.add_public_secondary_calldata(circuit.add_variable(val));
        }
        app_return_data.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));
        }
    };
 
    void tamper_with_app_return_data() { app_return_data.emplace_back(17); }
};
 
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)
        , total_num_circuits(num_app_circuits * 2 +
                             NUM_TRAILING_KERNELS) /*One kernel per app, plus a fixed number of final kernels*/
    {
        // Set flags indicating which circuits are kernels vs apps
        is_kernel_flags.resize(total_num_circuits, true);
        for (size_t i = 0; i < num_app_circuits; ++i) {
            is_kernel_flags[2 * i] = false; // every other circuit is an app
        }
    }
 
    static std::shared_ptr<VerificationKey> get_verification_key(ClientCircuit& builder_in)
    {
        // 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);
        std::shared_ptr<Chonk::ProverInstance> prover_instance = std::make_shared<Chonk::ProverInstance>(builder);
        std::shared_ptr<VerificationKey> vk = std::make_shared<VerificationKey>(prover_instance->get_precomputed());
        return vk;
    }
 
    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 = numeric::get_msb(prover_instance->get_metadata().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,
                                      16UL,
                                      "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 {
                        BB_ASSERT_EQ(log2_dyadic_size,
                                     18UL,
                                     "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
        if (ivc.num_circuits_accumulated == ivc.get_num_circuits() - 1) {
            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) };
    }
 
    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);
    }
 
    void tamper_with_databus() { mock_databus.tamper_with_app_return_data(); }
};
 
} // namespace