databus.hpp

Go to the documentation of this file.

// === AUDIT STATUS ===
// internal:    { status: Complete, auditors: [Khashayar], commit: }
// external_1:  { status: not started, auditors: [], commit: }
// external_2:  { status: not started, auditors: [], commit: }
// =====================
 
#pragma once
#include "../circuit_builders/circuit_builders_fwd.hpp"
#include "../field/field.hpp"
#include "barretenberg/stdlib/primitives/curves/bn254.hpp"
#include "barretenberg/stdlib/primitives/public_input_component/public_input_component.hpp"
#include "barretenberg/stdlib_circuit_builders/databus.hpp"
 
namespace bb::stdlib {
 
template <typename Builder> class databus {
  public:
    databus() = default;
 
  private:
    class bus_vector {
      private:
        using field_pt = field_t<Builder>;
 
      public:
        bus_vector() = default;
 
        bus_vector(const BusId bus_idx)
            : bus_idx(bus_idx) {};
 
        void set_values(const std::vector<field_pt>& entries_in)
            requires IsMegaBuilder<Builder>;
 
        field_pt operator[](const field_pt& index) const
            requires IsMegaBuilder<Builder>;
 
        size_t size() const { return length; }
        Builder* get_context() const { return context; }
        void set_context(Builder* builder_context) { context = builder_context; }
 
      private:
        mutable std::vector<field_pt> entries; // bus vector entries
        std::vector<OriginTag> _tags;          // origin tags for each entry (restored on read)
        size_t length = 0;
        BusId bus_idx; // Idx of column in bus
        mutable Builder* context = nullptr;
    };
 
  public:
    // The columns of the DataBus.
    bus_vector kernel_calldata{ BusId::KERNEL_CALLDATA };
    std::array<bus_vector, MAX_APPS_PER_KERNEL> app_calldata = []() {
        std::array<bus_vector, MAX_APPS_PER_KERNEL> result{};
        for (uint8_t idx = 0; idx < MAX_APPS_PER_KERNEL; ++idx) {
            result[idx] = bus_vector{ static_cast<BusId>(idx + 1) };
        }
        return result;
    }();
    bus_vector return_data{ BusId::RETURNDATA };
};
 
template <class Builder> class DataBusDepot {
  public:
    using Curve = stdlib::bn254<Builder>;
    using Commitment = typename Curve::Group;
    using CommitmentNative = typename Curve::AffineElementNative;
    using FrNative = typename Curve::ScalarFieldNative;
 
    // Storage for the return data commitments to be propagated via the public inputs
    std::array<Commitment, MAX_APPS_PER_KERNEL> app_return_data_commitments;
    Commitment kernel_return_data_commitment;
 
    // Existence flags indicating whether each return data commitment has been set
    std::array<bool, MAX_APPS_PER_KERNEL> app_return_data_commitment_exists = []() {
        std::array<bool, MAX_APPS_PER_KERNEL> result{};
        result.fill(false);
        return result;
    }();
    bool kernel_return_data_commitment_exists = false;
 
    void set_kernel_return_data_commitment(const Commitment& commitment)
    {
        kernel_return_data_commitment = commitment;
        kernel_return_data_commitment_exists = true;
    }
 
    bool app_return_data_slots_are_empty() const
    {
        for (size_t idx = 0; idx < MAX_APPS_PER_KERNEL; ++idx) {
            if (app_return_data_commitment_exists[idx]) {
                return false;
            }
        }
        return true;
    }
 
    void set_app_return_data_commitment(const Commitment& commitment)
    {
        for (size_t idx = 0; idx < MAX_APPS_PER_KERNEL; ++idx) {
            if (!app_return_data_commitment_exists[idx]) {
                app_return_data_commitments[idx] = commitment;
                app_return_data_commitment_exists[idx] = true;
                return;
            }
        }
        BB_ASSERT(false, "DataBusDepot has no free app return-data slot");
    }
 
    static Commitment construct_default_commitment(Builder& builder)
    {
        auto default_commitment = Commitment(CommitmentNative::infinity());
        default_commitment.convert_constant_to_fixed_witness(&builder);
        return default_commitment;
    }
 
    Commitment get_kernel_return_data_commitment(Builder& builder)
    {
        if (!kernel_return_data_commitment_exists) {
            return construct_default_commitment(builder);
        }
        kernel_return_data_commitment_exists = false; // Reset the existence flag after retrieval
        return kernel_return_data_commitment;
    }
 
    Commitment get_app_return_data_commitment(Builder& builder, const size_t idx)
    {
        BB_ASSERT_LT(idx, MAX_APPS_PER_KERNEL, "DataBusDepot app return-data index out of bounds");
        if (!app_return_data_commitment_exists[idx]) {
            return construct_default_commitment(builder);
        }
        app_return_data_commitment_exists[idx] = false; // Reset the existence flag after retrieval
        return app_return_data_commitments[idx];
    }
};
 
} // namespace bb::stdlib