emit_public_log.cpp

Go to the documentation of this file.

#include "barretenberg/vm2/simulation/gadgets/emit_public_log.hpp"
 
#include <cstdint>
#include <stdexcept>
 
namespace bb::avm2::simulation {
 
void EmitPublicLog::emit_public_log(MemoryInterface& memory,
                                    ContextInterface& context,
                                    const AztecAddress& contract_address,
                                    MemoryAddress log_address,
                                    uint32_t log_size)
{
    uint64_t end_log_address_upper_bound = static_cast<uint64_t>(log_address) + static_cast<uint64_t>(log_size);
    bool error_memory_out_of_bounds = greater_than.gt(end_log_address_upper_bound, AVM_MEMORY_SIZE);
 
    auto& side_effect_tracker = context.get_side_effect_tracker();
    uint32_t prev_emitted_log_fields = side_effect_tracker.get_side_effects().get_num_public_log_fields();
 
    uint64_t total_log_fields_size = PUBLIC_LOG_HEADER_LENGTH + log_size;
    uint64_t expected_next_emitted_log_fields = prev_emitted_log_fields + total_log_fields_size;
 
    bool error_too_many_log_fields = greater_than.gt(expected_next_emitted_log_fields, FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH);
 
    bool error_is_static = context.get_is_static();
 
    // Will be computed in the loop below
    bool error_tag_mismatch = false;
 
    std::vector<MemoryValue> values;
    if (!error_memory_out_of_bounds) {
        values.reserve(log_size);
        for (uint32_t i = 0; i < log_size; ++i) {
            MemoryValue value = memory.get(log_address + i);
            if (value.get_tag() != ValueTag::FF) {
                error_tag_mismatch = true;
            }
            values.push_back(value);
        }
    }
 
    bool error = error_memory_out_of_bounds || error_too_many_log_fields || error_tag_mismatch || error_is_static;
 
    if (!error) {
        side_effect_tracker.add_public_log(contract_address, std::vector<FF>(values.begin(), values.end()));
    }
 
    events.emit(EmitPublicLogWriteEvent{
        .execution_clk = execution_id_manager.get_execution_id(),
        .contract_address = contract_address,
        .space_id = memory.get_space_id(),
        .log_address = log_address,
        .log_size = log_size,
        .prev_num_public_log_fields = prev_emitted_log_fields,
        .next_num_public_log_fields = side_effect_tracker.get_side_effects().get_num_public_log_fields(),
        .is_static = error_is_static,
        .values = values,
        .error_memory_out_of_bounds = error_memory_out_of_bounds,
        .error_too_many_log_fields = error_too_many_log_fields,
        .error_tag_mismatch = error_tag_mismatch,
    });
 
    if (error_memory_out_of_bounds) {
        throw EmitPublicLogException("Memory out of bounds");
    }
    if (error_too_many_log_fields) {
        throw EmitPublicLogException("Too many logs");
    }
    if (error_tag_mismatch) {
        throw EmitPublicLogException("Tag mismatch");
    }
    if (error_is_static) {
        throw EmitPublicLogException("Static call cannot update the state.");
    }
}
 
void EmitPublicLog::on_checkpoint_created()
{
    events.emit(CheckPointEventType::CREATE_CHECKPOINT);
}
 
void EmitPublicLog::on_checkpoint_committed()
{
    events.emit(CheckPointEventType::COMMIT_CHECKPOINT);
}
 
void EmitPublicLog::on_checkpoint_reverted()
{
    events.emit(CheckPointEventType::REVERT_CHECKPOINT);
}
 
} // namespace bb::avm2::simulation