Barretenberg: src/barretenberg/vm2/simulation_helper.cpp Source File

#include "barretenberg/vm2/simulation_helper.hpp"


#include <cstdint>


#include "barretenberg/common/bb_bench.hpp"

#include "barretenberg/common/log.hpp"

#include "barretenberg/vm2/common/avm_io.hpp"

#include "barretenberg/vm2/common/aztec_types.hpp"

#include "barretenberg/vm2/common/field.hpp"


#include "barretenberg/vm2/simulation/interfaces/db.hpp"

#include "barretenberg/vm2/simulation/interfaces/debug_log.hpp"

#include "barretenberg/vm2/simulation/interfaces/update_check.hpp"

#include "barretenberg/vm2/simulation/lib/call_stack_metadata_collector.hpp"

#include "barretenberg/vm2/simulation/lib/db_types.hpp"

#include "barretenberg/vm2/simulation/lib/execution_id_manager.hpp"

#include "barretenberg/vm2/simulation/lib/hinting_dbs.hpp"

#include "barretenberg/vm2/simulation/lib/instruction_info.hpp"

#include "barretenberg/vm2/simulation/lib/public_inputs_builder.hpp"

#include "barretenberg/vm2/simulation/lib/raw_data_dbs.hpp"

#include "barretenberg/vm2/simulation/lib/side_effect_tracker.hpp"

#include "barretenberg/vm2/simulation/lib/side_effect_tracking_db.hpp"


// Events.

#include "barretenberg/vm2/simulation/events/address_derivation_event.hpp"

#include "barretenberg/vm2/simulation/events/addressing_event.hpp"

#include "barretenberg/vm2/simulation/events/alu_event.hpp"

#include "barretenberg/vm2/simulation/events/bitwise_event.hpp"

#include "barretenberg/vm2/simulation/events/bytecode_events.hpp"

#include "barretenberg/vm2/simulation/events/class_id_derivation_event.hpp"

#include "barretenberg/vm2/simulation/events/contract_instance_retrieval_event.hpp"

#include "barretenberg/vm2/simulation/events/ecc_events.hpp"

#include "barretenberg/vm2/simulation/events/event_emitter.hpp"

#include "barretenberg/vm2/simulation/events/execution_event.hpp"

#include "barretenberg/vm2/simulation/events/field_gt_event.hpp"

#include "barretenberg/vm2/simulation/events/get_contract_instance_event.hpp"

#include "barretenberg/vm2/simulation/events/indexed_tree_check_event.hpp"

#include "barretenberg/vm2/simulation/events/keccakf1600_event.hpp"

#include "barretenberg/vm2/simulation/events/memory_event.hpp"

#include "barretenberg/vm2/simulation/events/merkle_check_event.hpp"

#include "barretenberg/vm2/simulation/events/public_data_tree_check_event.hpp"

#include "barretenberg/vm2/simulation/events/range_check_event.hpp"

#include "barretenberg/vm2/simulation/events/sha256_event.hpp"

#include "barretenberg/vm2/simulation/events/to_radix_event.hpp"

#include "barretenberg/vm2/simulation/events/tx_events.hpp"

#include "barretenberg/vm2/simulation/events/update_check.hpp"


// Gadgets.

#include "barretenberg/aztec/aztec_constants.hpp"

#include "barretenberg/vm2/simulation/gadgets/addressing.hpp"

#include "barretenberg/vm2/simulation/gadgets/alu.hpp"

#include "barretenberg/vm2/simulation/gadgets/bitwise.hpp"

#include "barretenberg/vm2/simulation/gadgets/bytecode_manager.hpp"

#include "barretenberg/vm2/simulation/gadgets/calldata_hashing.hpp"

#include "barretenberg/vm2/simulation/gadgets/concrete_dbs.hpp"

#include "barretenberg/vm2/simulation/gadgets/context.hpp"

#include "barretenberg/vm2/simulation/gadgets/contract_instance_manager.hpp"

#include "barretenberg/vm2/simulation/gadgets/data_copy.hpp"

#include "barretenberg/vm2/simulation/gadgets/ecc.hpp"

#include "barretenberg/vm2/simulation/gadgets/emit_public_log.hpp"

#include "barretenberg/vm2/simulation/gadgets/execution.hpp"

#include "barretenberg/vm2/simulation/gadgets/execution_components.hpp"

#include "barretenberg/vm2/simulation/gadgets/field_gt.hpp"

#include "barretenberg/vm2/simulation/gadgets/get_contract_instance.hpp"

#include "barretenberg/vm2/simulation/gadgets/gt.hpp"

#include "barretenberg/vm2/simulation/gadgets/internal_call_stack_manager.hpp"

#include "barretenberg/vm2/simulation/gadgets/keccakf1600.hpp"

#include "barretenberg/vm2/simulation/gadgets/memory.hpp"

#include "barretenberg/vm2/simulation/gadgets/merkle_check.hpp"

#include "barretenberg/vm2/simulation/gadgets/poseidon2.hpp"

#include "barretenberg/vm2/simulation/gadgets/range_check.hpp"

#include "barretenberg/vm2/simulation/gadgets/sha256.hpp"

#include "barretenberg/vm2/simulation/gadgets/to_radix.hpp"

#include "barretenberg/vm2/simulation/gadgets/tx_execution.hpp"

#include "barretenberg/vm2/simulation/gadgets/update_check.hpp"

#include "barretenberg/vm2/simulation/gadgets/written_public_data_slots_tree_check.hpp"


// Standalone.

#include "barretenberg/vm2/simulation/standalone/concrete_dbs.hpp"

#include "barretenberg/vm2/simulation/standalone/debug_log.hpp"

#include "barretenberg/vm2/simulation/standalone/hybrid_execution.hpp"

#include "barretenberg/vm2/simulation/standalone/noop_calldata_hashing.hpp"

#include "barretenberg/vm2/simulation/standalone/noop_update_check.hpp"

#include "barretenberg/vm2/simulation/standalone/pure_alu.hpp"

#include "barretenberg/vm2/simulation/standalone/pure_bitwise.hpp"

#include "barretenberg/vm2/simulation/standalone/pure_bytecode_manager.hpp"

#include "barretenberg/vm2/simulation/standalone/pure_execution_components.hpp"

#include "barretenberg/vm2/simulation/standalone/pure_gt.hpp"

#include "barretenberg/vm2/simulation/standalone/pure_keccakf1600.hpp"

#include "barretenberg/vm2/simulation/standalone/pure_memory.hpp"

#include "barretenberg/vm2/simulation/standalone/pure_poseidon2.hpp"

#include "barretenberg/vm2/simulation/standalone/pure_sha256.hpp"

#include "barretenberg/vm2/simulation/standalone/pure_to_radix.hpp"

#include "barretenberg/vm2/simulation/standalone/written_public_data_slots_tree_check.hpp"


namespace bb::avm2 {


using namespace bb::avm2::simulation;


namespace {


PublicTxEffect extract_public_tx_effect(const TxExecutionResult& tx_execution_result,

                                        const SideEffectTrackerInterface& side_effect_tracker)

{

    PublicTxEffect public_tx_effect;

    const auto& side_effects = side_effect_tracker.get_side_effects();

    public_tx_effect.transaction_fee = tx_execution_result.transaction_fee;

    public_tx_effect.note_hashes = side_effects.note_hashes;

    public_tx_effect.nullifiers = side_effects.nullifiers;

    public_tx_effect.l2_to_l1_msgs = side_effects.l2_to_l1_messages;

    public_tx_effect.public_logs = side_effects.public_logs.to_logs();


    // We need to copy the storage writes slot to value in the order of the slots by insertion.

    const size_t num_storage_writes = side_effects.storage_writes_slots_by_insertion.size();

    public_tx_effect.public_data_writes.reserve(num_storage_writes);

    for (size_t i = 0; i < num_storage_writes; i++) {

        const auto& slot = side_effects.storage_writes_slots_by_insertion[i];

        const auto& value = side_effects.storage_writes_slot_to_value.at(slot);

        public_tx_effect.public_data_writes.push_back(PublicDataWrite{ .leaf_slot = slot, .value = value });

    }


    return public_tx_effect;

}


} // namespace


// Internal helper function for event-generating simulation (with full gadgets).

// NOTE: Some of the config parameters are ignored in this function.

template <template <typename> class DefaultEventEmitter, template <typename> class DefaultDeduplicatingEventEmitter>


std::tuple<EventsContainer, TxSimulationResult> AvmSimulationHelper::simulate_for_witgen_internal(

    ContractDBInterface& raw_contract_db,

    LowLevelMerkleDBInterface& raw_merkle_db,

    const PublicSimulatorConfig& config,

    const Tx& tx,

    const GlobalVariables& global_variables,

    const ProtocolContracts& protocol_contracts)

{

    BB_BENCH_NAME("AvmSimulationHelper::simulate_for_witgen_internal");


    DefaultEventEmitter<ExecutionEvent> execution_emitter;

    DefaultDeduplicatingEventEmitter<AluEvent> alu_emitter;

    DefaultDeduplicatingEventEmitter<BitwiseEvent> bitwise_emitter;

    DefaultEventEmitter<DataCopyEvent> data_copy_emitter;

    DefaultEventEmitter<MemoryEvent> memory_emitter;

    DefaultEventEmitter<BytecodeRetrievalEvent> bytecode_retrieval_emitter;

    DefaultEventEmitter<BytecodeHashingEvent> bytecode_hashing_emitter;

    DefaultEventEmitter<BytecodeDecompositionEvent> bytecode_decomposition_emitter;

    DefaultDeduplicatingEventEmitter<InstructionFetchingEvent> instruction_fetching_emitter;

    DefaultEventEmitter<AddressDerivationEvent> address_derivation_emitter;

    DefaultEventEmitter<ClassIdDerivationEvent> class_id_derivation_emitter;

    DefaultEventEmitter<Sha256CompressionEvent> sha256_compression_emitter;

    DefaultEventEmitter<EccAddEvent> ecc_add_emitter;

    DefaultEventEmitter<ScalarMulEvent> scalar_mul_emitter;

    DefaultEventEmitter<EccAddMemoryEvent> ecc_add_memory_emitter;

    DefaultEventEmitter<Poseidon2HashEvent> poseidon2_hash_emitter;

    DefaultEventEmitter<Poseidon2PermutationEvent> poseidon2_perm_emitter;

    DefaultEventEmitter<Poseidon2PermutationMemoryEvent> poseidon2_perm_mem_emitter;

    DefaultEventEmitter<KeccakF1600Event> keccakf1600_emitter;

    DefaultEventEmitter<ToRadixEvent> to_radix_emitter;

    DefaultEventEmitter<ToRadixMemoryEvent> to_radix_memory_emitter;

    DefaultDeduplicatingEventEmitter<FieldGreaterThanEvent> field_gt_emitter;

    DefaultEventEmitter<MerkleCheckEvent> merkle_check_emitter;

    DefaultDeduplicatingEventEmitter<RangeCheckEvent> range_check_emitter;

    DefaultEventEmitter<ContextStackEvent> context_stack_emitter;

    DefaultEventEmitter<PublicDataTreeCheckEvent> public_data_tree_check_emitter;

    DefaultEventEmitter<UpdateCheckEvent> update_check_emitter;

    DefaultEventEmitter<IndexedTreeCheckEvent> indexed_tree_check_emitter;

    DefaultEventEmitter<TxEvent> tx_event_emitter;

    DefaultEventEmitter<CalldataEvent> calldata_emitter;

    DefaultEventEmitter<InternalCallStackEvent> internal_call_stack_emitter;

    DefaultEventEmitter<NoteHashTreeCheckEvent> note_hash_tree_check_emitter;

    DefaultDeduplicatingEventEmitter<GreaterThanEvent> greater_than_emitter;

    DefaultEventEmitter<ContractInstanceRetrievalEvent> contract_instance_retrieval_emitter;

    DefaultEventEmitter<GetContractInstanceEvent> get_contract_instance_emitter;

    DefaultEventEmitter<L1ToL2MessageTreeCheckEvent> l1_to_l2_msg_tree_check_emitter;

    DefaultEventEmitter<EmitPublicLogEvent> emit_public_log_emitter;


    ExecutionIdManager execution_id_manager(1);

    RangeCheck range_check(range_check_emitter);

    FieldGreaterThan field_gt(range_check, field_gt_emitter);

    GreaterThan greater_than(field_gt, range_check, greater_than_emitter);

    ToRadix to_radix(execution_id_manager, greater_than, to_radix_emitter, to_radix_memory_emitter);

    Poseidon2 poseidon2(

        execution_id_manager, greater_than, poseidon2_hash_emitter, poseidon2_perm_emitter, poseidon2_perm_mem_emitter);

    MerkleCheck merkle_check(poseidon2, merkle_check_emitter);


    PublicDataTreeCheck public_data_tree_check(

        poseidon2, merkle_check, field_gt, execution_id_manager, public_data_tree_check_emitter);

    IndexedTreeCheck indexed_tree_check(

        poseidon2, merkle_check, field_gt, DOM_SEP__NULLIFIER_MERKLE, indexed_tree_check_emitter);

    IndexedTreeCheck indexed_tree_check_written_slots(

        poseidon2, merkle_check, field_gt, DOM_SEP__WRITTEN_SLOTS_MERKLE, indexed_tree_check_emitter);

    IndexedTreeCheck indexed_tree_check_retrieved_bytecodes(

        poseidon2, merkle_check, field_gt, DOM_SEP__RETRIEVED_BYTECODES_MERKLE, indexed_tree_check_emitter);


    WrittenPublicDataSlotsTreeCheck written_public_data_slots_tree_check(indexed_tree_check_written_slots,

                                                                         build_public_data_slots_tree());

    RetrievedBytecodesTreeCheck retrieved_bytecodes_tree_check(indexed_tree_check_retrieved_bytecodes,

                                                               build_retrieved_bytecodes_tree());


    // The protocol requires at least one non-revertible nullifier in the transaction (used for uniqueness of note

    // hashes).

    if (tx.non_revertible_accumulated_data.nullifiers.empty()) {

        throw std::runtime_error("Non-revertible nullifiers are empty in the transaction.");

    }


    NoteHashTreeCheck note_hash_tree_check(

        tx.non_revertible_accumulated_data.nullifiers[0], poseidon2, merkle_check, note_hash_tree_check_emitter);

    L1ToL2MessageTreeCheck l1_to_l2_msg_tree_check(merkle_check, l1_to_l2_msg_tree_check_emitter);

    EmitPublicLog emit_public_log_component(execution_id_manager, greater_than, emit_public_log_emitter);

    Alu alu(greater_than, field_gt, range_check, alu_emitter);

    Bitwise bitwise(bitwise_emitter);

    Sha256 sha256(execution_id_manager, bitwise, greater_than, sha256_compression_emitter);

    KeccakF1600 keccakf1600(execution_id_manager, keccakf1600_emitter, bitwise, range_check, greater_than);


    Ecc ecc(execution_id_manager, greater_than, to_radix, ecc_add_emitter, scalar_mul_emitter, ecc_add_memory_emitter);

    AddressDerivation address_derivation(poseidon2, ecc, address_derivation_emitter);

    ClassIdDerivation class_id_derivation(poseidon2, class_id_derivation_emitter);


    ContractDB contract_db(raw_contract_db, address_derivation, class_id_derivation, protocol_contracts);


    MerkleDB base_merkle_db(raw_merkle_db,

                            public_data_tree_check,

                            indexed_tree_check,

                            note_hash_tree_check,

                            written_public_data_slots_tree_check,

                            l1_to_l2_msg_tree_check);

    base_merkle_db.add_checkpoint_listener(note_hash_tree_check);

    base_merkle_db.add_checkpoint_listener(indexed_tree_check);

    base_merkle_db.add_checkpoint_listener(public_data_tree_check);

    // This one is only needed for events.

    base_merkle_db.add_checkpoint_listener(emit_public_log_component);


    // Side effect tracking is only strictly needed for logs and L2-to-L1 messages.

    SideEffectTracker side_effect_tracker;


    SideEffectTrackingDB merkle_db(

        tx.non_revertible_accumulated_data.nullifiers[0], base_merkle_db, side_effect_tracker);


    UpdateCheck update_check(poseidon2, range_check, greater_than, merkle_db, update_check_emitter, global_variables);


    BytecodeHasher bytecode_hasher(poseidon2, bytecode_hashing_emitter);

    InstructionInfoDB instruction_info_db;


    ContractInstanceManager contract_instance_manager(

        contract_db, merkle_db, update_check, field_gt, protocol_contracts, contract_instance_retrieval_emitter);


    TxBytecodeManager bytecode_manager(contract_db,

                                       merkle_db,

                                       bytecode_hasher,

                                       range_check,

                                       contract_instance_manager,

                                       retrieved_bytecodes_tree_check,

                                       bytecode_retrieval_emitter,

                                       bytecode_decomposition_emitter,

                                       instruction_fetching_emitter);

    ExecutionComponentsProvider execution_components(greater_than, instruction_info_db);


    MemoryProvider memory_provider(range_check, execution_id_manager, memory_emitter);

    CalldataHashingProvider calldata_hashing_provider(poseidon2, calldata_emitter);

    InternalCallStackManagerProvider internal_call_stack_manager_provider(internal_call_stack_emitter);

    ContextProvider context_provider(bytecode_manager,

                                     memory_provider,

                                     calldata_hashing_provider,

                                     internal_call_stack_manager_provider,

                                     merkle_db,

                                     written_public_data_slots_tree_check,

                                     retrieved_bytecodes_tree_check,

                                     side_effect_tracker,

                                     global_variables);

    DataCopy data_copy(execution_id_manager, greater_than, data_copy_emitter);


    // Create GetContractInstance opcode component

    GetContractInstance get_contract_instance(

        execution_id_manager, merkle_db, get_contract_instance_emitter, contract_instance_manager);


    NoopDebugLogger debug_log_component;

    auto call_stack_metadata_collector =

        config.collect_call_metadata ? static_cast<std::unique_ptr<CallStackMetadataCollectorInterface>>(

                                           std::make_unique<CallStackMetadataCollector>(config.collection_limits))

                                     : static_cast<std::unique_ptr<CallStackMetadataCollectorInterface>>(

                                           std::make_unique<NoopCallStackMetadataCollector>());


    Execution execution(alu,

                        bitwise,

                        data_copy,

                        poseidon2,

                        ecc,

                        to_radix,

                        sha256,

                        execution_components,

                        context_provider,

                        instruction_info_db,

                        execution_id_manager,

                        execution_emitter,

                        context_stack_emitter,

                        keccakf1600,

                        greater_than,

                        get_contract_instance,

                        emit_public_log_component,

                        debug_log_component,

                        merkle_db,

                        *call_stack_metadata_collector);


    TxExecution tx_execution(execution,

                             context_provider,

                             contract_db,

                             merkle_db,

                             written_public_data_slots_tree_check,

                             retrieved_bytecodes_tree_check,

                             side_effect_tracker,

                             field_gt,

                             poseidon2,

                             *call_stack_metadata_collector,

                             tx_event_emitter);


    PublicInputsBuilder public_inputs_builder;

    public_inputs_builder.extract_inputs(tx, global_variables, protocol_contracts, config.prover_id, raw_merkle_db);


    TxExecutionResult tx_execution_result = tx_execution.simulate(tx);


    public_inputs_builder.extract_outputs(raw_merkle_db,

                                          // TODO(MW): Use of billed_gas is a bit misleading - we want public + private

                                          // - teardown, which is stored as billed gas here/in ts:

                                          tx_execution_result.gas_used.billed_gas,

                                          tx_execution_result.transaction_fee,

                                          tx_execution_result.revert_code != RevertCode::OK,

                                          side_effect_tracker.get_side_effects());


    public_data_tree_check.generate_ff_gt_events_for_squashing(

        side_effect_tracker.get_side_effects().storage_writes_slots_by_insertion);


    EventsContainer events = {

        tx_event_emitter.dump_events(),

        execution_emitter.dump_events(),

        alu_emitter.dump_events(),

        bitwise_emitter.dump_events(),

        memory_emitter.dump_events(),

        bytecode_retrieval_emitter.dump_events(),

        bytecode_hashing_emitter.dump_events(),

        bytecode_decomposition_emitter.dump_events(),

        instruction_fetching_emitter.dump_events(),

        address_derivation_emitter.dump_events(),

        class_id_derivation_emitter.dump_events(),

        sha256_compression_emitter.dump_events(),

        ecc_add_emitter.dump_events(),

        scalar_mul_emitter.dump_events(),

        ecc_add_memory_emitter.dump_events(),

        poseidon2_hash_emitter.dump_events(),

        poseidon2_perm_emitter.dump_events(),

        poseidon2_perm_mem_emitter.dump_events(),

        keccakf1600_emitter.dump_events(),

        to_radix_emitter.dump_events(),

        to_radix_memory_emitter.dump_events(),

        field_gt_emitter.dump_events(),

        greater_than_emitter.dump_events(),

        merkle_check_emitter.dump_events(),

        range_check_emitter.dump_events(),

        context_stack_emitter.dump_events(),

        public_data_tree_check_emitter.dump_events(),

        update_check_emitter.dump_events(),

        indexed_tree_check_emitter.dump_events(),

        data_copy_emitter.dump_events(),

        calldata_emitter.dump_events(),

        internal_call_stack_emitter.dump_events(),

        note_hash_tree_check_emitter.dump_events(),

        contract_instance_retrieval_emitter.dump_events(),

        get_contract_instance_emitter.dump_events(),

        l1_to_l2_msg_tree_check_emitter.dump_events(),

        emit_public_log_emitter.dump_events(),

    };


    TxSimulationResult tx_simulation_result = {

        .gas_used = tx_execution_result.gas_used,

        .revert_code = tx_execution_result.revert_code,

        .public_tx_effect = extract_public_tx_effect(tx_execution_result, side_effect_tracker),

        .call_stack_metadata = call_stack_metadata_collector->dump_call_stack_metadata(),

        .logs = debug_log_component.dump_logs(),

        .public_inputs =

            config.collect_public_inputs ? std::make_optional(public_inputs_builder.build()) : std::nullopt,

    };


    return { std::move(events), std::move(tx_simulation_result) };

}


// Internal helper function for fast simulation.


TxSimulationResult AvmSimulationHelper::simulate_fast_internal(ContractDBInterface& raw_contract_db,

                                                               LowLevelMerkleDBInterface& raw_merkle_db,

                                                               const PublicSimulatorConfig& config,

                                                               const Tx& tx,

                                                               const GlobalVariables& global_variables,

                                                               const ProtocolContracts& protocol_contracts,

                                                               CancellationTokenPtr cancellation_token)

{

    BB_BENCH_NAME("AvmSimulationHelper::simulate_fast_internal");


    NoopEventEmitter<ExecutionEvent> execution_emitter;

    NoopEventEmitter<DataCopyEvent> data_copy_emitter;

    NoopEventEmitter<EccAddEvent> ecc_add_emitter;

    NoopEventEmitter<ScalarMulEvent> scalar_mul_emitter;

    NoopEventEmitter<EccAddMemoryEvent> ecc_add_memory_emitter;

    NoopEventEmitter<FieldGreaterThanEvent> field_gt_emitter;

    NoopEventEmitter<MerkleCheckEvent> merkle_check_emitter;

    NoopEventEmitter<RangeCheckEvent> range_check_emitter;

    NoopEventEmitter<ContextStackEvent> context_stack_emitter;

    NoopEventEmitter<TxEvent> tx_event_emitter;

    NoopEventEmitter<InternalCallStackEvent> internal_call_stack_emitter;

    NoopEventEmitter<ContractInstanceRetrievalEvent> contract_instance_retrieval_emitter;

    NoopEventEmitter<GetContractInstanceEvent> get_contract_instance_emitter;

    NoopEventEmitter<EmitPublicLogEvent> emit_public_log_emitter;

    NoopEventEmitter<UpdateCheckEvent> update_check_emitter;

    NoopEventEmitter<IndexedTreeCheckEvent> indexed_tree_check_emitter;


    ExecutionIdManager execution_id_manager(1);

    RangeCheck range_check(range_check_emitter);

    FieldGreaterThan field_gt(range_check, field_gt_emitter);

    PureGreaterThan greater_than;

    PureToRadix to_radix;

    PurePoseidon2 poseidon2;

    MerkleCheck merkle_check(poseidon2, merkle_check_emitter);

    PureWrittenPublicDataSlotsTreeCheck written_public_data_slots_tree_check(poseidon2);

    IndexedTreeCheck indexed_tree_check_retrieved_bytecodes(

        poseidon2, merkle_check, field_gt, DOM_SEP__RETRIEVED_BYTECODES_MERKLE, indexed_tree_check_emitter);

    RetrievedBytecodesTreeCheck retrieved_bytecodes_tree_check(indexed_tree_check_retrieved_bytecodes,

                                                               build_retrieved_bytecodes_tree());

    EmitPublicLog emit_public_log_component(execution_id_manager, greater_than, emit_public_log_emitter);

    PureAlu alu;

    PureBitwise bitwise;

    PureSha256 sha256;

    PureKeccakF1600 keccakf1600;


    Ecc ecc(execution_id_manager, greater_than, to_radix, ecc_add_emitter, scalar_mul_emitter, ecc_add_memory_emitter);


    SideEffectTracker side_effect_tracker;

    PureContractDB contract_db(raw_contract_db);


    // The protocol requires at least one non-revertible nullifier in the transaction (used for uniqueness of note

    // hashes).

    if (tx.non_revertible_accumulated_data.nullifiers.empty()) {

        throw std::runtime_error("Non-revertible nullifiers are empty in the transaction.");

    }


    PureMerkleDB base_merkle_db(

        tx.non_revertible_accumulated_data.nullifiers[0], raw_merkle_db, written_public_data_slots_tree_check);

    SideEffectTrackingDB merkle_db(


        tx.non_revertible_accumulated_data.nullifiers[0], base_merkle_db, side_effect_tracker);


    NoopUpdateCheck update_check;

    InstructionInfoDB instruction_info_db;


    ContractInstanceManager contract_instance_manager(

        contract_db, merkle_db, update_check, field_gt, protocol_contracts, contract_instance_retrieval_emitter);

    PureTxBytecodeManager tx_bytecode_manager(contract_db, contract_instance_manager);


    PureExecutionComponentsProvider execution_components(greater_than, instruction_info_db);


    PureMemoryProvider memory_provider;

    NoopCalldataHashingProvider calldata_hashing_provider;

    InternalCallStackManagerProvider internal_call_stack_manager_provider(internal_call_stack_emitter);

    ContextProvider context_provider(tx_bytecode_manager,

                                     memory_provider,

                                     calldata_hashing_provider,

                                     internal_call_stack_manager_provider,

                                     merkle_db,

                                     written_public_data_slots_tree_check,

                                     retrieved_bytecodes_tree_check,

                                     side_effect_tracker,

                                     global_variables);

    DataCopy data_copy(execution_id_manager, greater_than, data_copy_emitter);


    // Create GetContractInstance opcode component

    GetContractInstance get_contract_instance(

        execution_id_manager, merkle_db, get_contract_instance_emitter, contract_instance_manager);


    std::unique_ptr<DebugLoggerInterface> debug_log_component = [&config]() -> std::unique_ptr<DebugLoggerInterface> {

        if (config.collect_debug_logs) {

            // TODO(fcarreiro): add debug log level?

            const DebugLogLevel debug_log_level = DebugLogLevel::INFO;

            return std::make_unique<DebugLogger>(debug_log_level,

                                                 config.collection_limits.max_debug_log_memory_reads,

                                                 [](const std::string& message) { vinfo(message); });

        } else {

            return std::make_unique<NoopDebugLogger>();

        }

    }();

    auto call_stack_metadata_collector =

        config.collect_call_metadata ? static_cast<std::unique_ptr<CallStackMetadataCollectorInterface>>(

                                           std::make_unique<CallStackMetadataCollector>(config.collection_limits))

                                     : static_cast<std::unique_ptr<CallStackMetadataCollectorInterface>>(

                                           std::make_unique<NoopCallStackMetadataCollector>());


    HybridExecution execution(alu,

                              bitwise,

                              data_copy,

                              poseidon2,

                              ecc,

                              to_radix,

                              sha256,

                              execution_components,

                              context_provider,

                              instruction_info_db,

                              execution_id_manager,

                              execution_emitter,

                              context_stack_emitter,

                              keccakf1600,

                              greater_than,

                              get_contract_instance,

                              emit_public_log_component,

                              *debug_log_component,

                              merkle_db,

                              *call_stack_metadata_collector,

                              std::move(cancellation_token));

    TxExecution tx_execution(execution,

                             context_provider,

                             contract_db,

                             merkle_db,

                             written_public_data_slots_tree_check,

                             retrieved_bytecodes_tree_check,

                             side_effect_tracker,

                             field_gt,

                             poseidon2,

                             *call_stack_metadata_collector,

                             tx_event_emitter,

                             config.skip_fee_enforcement);


    PublicInputsBuilder public_inputs_builder;

    public_inputs_builder.extract_inputs(tx, global_variables, protocol_contracts, config.prover_id, raw_merkle_db);


    // This triggers all the work.

    TxExecutionResult tx_execution_result = tx_execution.simulate(tx);


    public_inputs_builder.extract_outputs(raw_merkle_db,

                                          // TODO(MW): Use of billed_gas is a bit misleading - we want public + private

                                          // - teardown, which is stored as billed gas here/in ts:

                                          tx_execution_result.gas_used.billed_gas,

                                          tx_execution_result.transaction_fee,

                                          tx_execution_result.revert_code != RevertCode::OK,

                                          side_effect_tracker.get_side_effects());


    return {

        // Simulation.

        .gas_used = tx_execution_result.gas_used,

        .revert_code = tx_execution_result.revert_code,

        .public_tx_effect = extract_public_tx_effect(tx_execution_result, side_effect_tracker),

        .call_stack_metadata = call_stack_metadata_collector->dump_call_stack_metadata(),

        .logs = debug_log_component->dump_logs(),

        // Proving request data.

        .public_inputs =

            config.collect_public_inputs ? std::make_optional(public_inputs_builder.build()) : std::nullopt,

        .hints = std::nullopt, // NOTE: hints are injected by the caller.

    };

}


/************************************

 * Entry points

 ************************************/


TxSimulationResult AvmSimulationHelper::simulate_fast_with_existing_ws(

    simulation::ContractDBInterface& raw_contract_db,

    const world_state::WorldStateRevision& world_state_revision,

    world_state::WorldState& ws,

    const PublicSimulatorConfig& config,

    const Tx& tx,

    const GlobalVariables& global_variables,

    const ProtocolContracts& protocol_contracts,

    CancellationTokenPtr cancellation_token)

{

    // For collecting hints, use the other method.

    BB_ASSERT(!config.collect_hints && "Use simulate_for_hint_collection instead");


    // Create PureRawMerkleDB with the provided WorldState instance and cancellation token

    PureRawMerkleDB raw_merkle_db(world_state_revision, ws, /*cache_tree_roots=*/true, cancellation_token);


    return simulate_fast_internal(

        raw_contract_db, raw_merkle_db, config, tx, global_variables, protocol_contracts, cancellation_token);

}


TxSimulationResult AvmSimulationHelper::simulate_for_hint_collection(

    simulation::ContractDBInterface& raw_contract_db,

    const world_state::WorldStateRevision& world_state_revision,

    world_state::WorldState& ws,

    const PublicSimulatorConfig& config,

    const Tx& tx,

    const GlobalVariables& global_variables,

    const ProtocolContracts& protocol_contracts,

    CancellationTokenPtr cancellation_token)

{

    // If you are not collecting hints, don't use this method.

    BB_ASSERT(config.collect_hints && "Use simulate_fast_with_existing_ws instead");


    // Create PureRawMerkleDB with the provided WorldState instance and cancellation token

    PureRawMerkleDB raw_merkle_db(world_state_revision, ws, /*cache_tree_roots=*/true, cancellation_token);


    auto starting_tree_roots = raw_merkle_db.get_tree_roots();

    HintingContractsDB hinting_contract_db(raw_contract_db);

    HintingRawDB hinting_merkle_db(raw_merkle_db);


    // We use NoopEventEmitters here because we don't want to collect events.

    auto [/* unused */ events_, tx_result] = simulate_for_witgen_internal<NoopEventEmitter, NoopEventEmitter>(

        hinting_contract_db, hinting_merkle_db, config, tx, global_variables, protocol_contracts);


    ExecutionHints collected_hints = ExecutionHints{ .global_variables = global_variables,

                                                     .tx = tx,

                                                     .protocol_contracts = protocol_contracts,

                                                     .starting_tree_roots = starting_tree_roots };

    hinting_contract_db.dump_hints(collected_hints);

    hinting_merkle_db.dump_hints(collected_hints);


    tx_result.hints = std::move(collected_hints);


    // Need to std::move to avoid copying (due to structured bindings).

    // This was fixed in C++23 via http://wg21.link/P2266R3.

    return std::move(tx_result);

}


EventsContainer AvmSimulationHelper::simulate_for_witgen(const ExecutionHints& hints)

{

    // TODO(fcarreiro): decide if we want to pass a config here.

    const PublicSimulatorConfig config{};


    HintedRawContractDB raw_contract_db(hints);

    HintedRawMerkleDB raw_merkle_db(hints);


    // We use EventEmitters and DeduplicatingEventEmitters here because we want to collect events.

    auto [events, /* unused */ tx_result_] = simulate_for_witgen_internal<EventEmitter, DeduplicatingEventEmitter>(

        raw_contract_db, raw_merkle_db, config, hints.tx, hints.global_variables, hints.protocol_contracts);


    // Need to std::move to avoid copying (due to structured bindings).

    // This was fixed in C++23 via http://wg21.link/P2266R3.

    return std::move(events);

}


TxSimulationResult AvmSimulationHelper::simulate_fast_with_hinted_dbs(const ExecutionHints& hints,

                                                                      const PublicSimulatorConfig& config)

{

    HintedRawContractDB raw_contract_db(hints);

    HintedRawMerkleDB raw_merkle_db(hints);

    return simulate_fast_internal(

        raw_contract_db, raw_merkle_db, config, hints.tx, hints.global_variables, hints.protocol_contracts);

}


} // namespace bb::avm2

address_derivation_event.hpp

addressing_event.hpp

alu_event.hpp

greater_than
GreaterThan greater_than
Definition alu_integration.test.cpp:65

alu_emitter
EventEmitter< AluEvent > alu_emitter
Definition alu_integration.test.cpp:60

BB_ASSERT
#define BB_ASSERT(expression,...)
Definition assert.hpp:70

avm_io.hpp

aztec_constants.hpp

DOM_SEP__WRITTEN_SLOTS_MERKLE
#define DOM_SEP__WRITTEN_SLOTS_MERKLE
Definition aztec_constants.hpp:269

DOM_SEP__NULLIFIER_MERKLE
#define DOM_SEP__NULLIFIER_MERKLE
Definition aztec_constants.hpp:267

DOM_SEP__RETRIEVED_BYTECODES_MERKLE
#define DOM_SEP__RETRIEVED_BYTECODES_MERKLE
Definition aztec_constants.hpp:270

aztec_types.hpp

bb_bench.hpp

BB_BENCH_NAME
#define BB_BENCH_NAME(name)
Definition bb_bench.hpp:264

field_gt
FieldGreaterThan field_gt
Definition bc_retrieval.test.cpp:312

merkle_check_emitter
EventEmitter< simulation::MerkleCheckEvent > merkle_check_emitter
Definition bc_retrieval.test.cpp:298

retrieved_bytecodes_tree_check
RetrievedBytecodesTreeCheck retrieved_bytecodes_tree_check
Definition bc_retrieval.test.cpp:316

field_gt_emitter
EventEmitter< simulation::FieldGreaterThanEvent > field_gt_emitter
Definition bc_retrieval.test.cpp:300

range_check_emitter
EventEmitter< simulation::RangeCheckEvent > range_check_emitter
Definition bc_retrieval.test.cpp:299

bitwise_event.hpp

bytecode_events.hpp

bytecode_hasher
BytecodeHasher bytecode_hasher
Definition bytecode_hashing.test.cpp:43

merkle_db
StrictMock< MockHighLevelMerkleDB > merkle_db
Definition bytecode_manager.test.cpp:53

contract_db
StrictMock< MockContractDB > contract_db
Definition bytecode_manager.test.cpp:52

contract_instance_manager
StrictMock< MockContractInstanceManager > contract_instance_manager
Definition bytecode_manager.test.cpp:56

class_id_derivation_event.hpp

bb::avm2::AvmSimulationHelper::simulate_fast_internal
TxSimulationResult simulate_fast_internal(simulation::ContractDBInterface &raw_contract_db, simulation::LowLevelMerkleDBInterface &raw_merkle_db, const PublicSimulatorConfig &config, const Tx &tx, const GlobalVariables &global_variables, const ProtocolContracts &protocol_contracts, simulation::CancellationTokenPtr cancellation_token=nullptr)
Definition simulation_helper.cpp:387

bb::avm2::AvmSimulationHelper::simulate_for_witgen_internal
std::tuple< simulation::EventsContainer, TxSimulationResult > simulate_for_witgen_internal(simulation::ContractDBInterface &raw_contract_db, simulation::LowLevelMerkleDBInterface &raw_merkle_db, const PublicSimulatorConfig &config, const Tx &tx, const GlobalVariables &global_variables, const ProtocolContracts &protocol_contracts)

bb::avm2::AvmSimulationHelper::simulate_for_hint_collection
TxSimulationResult simulate_for_hint_collection(simulation::ContractDBInterface &raw_contract_db, const world_state::WorldStateRevision &world_state_revision, world_state::WorldState &ws, const PublicSimulatorConfig &config, const Tx &tx, const GlobalVariables &global_variables, const ProtocolContracts &protocol_contracts, simulation::CancellationTokenPtr cancellation_token=nullptr)
Definition simulation_helper.cpp:579

bb::avm2::AvmSimulationHelper::simulate_fast_with_hinted_dbs
TxSimulationResult simulate_fast_with_hinted_dbs(const ExecutionHints &hints, const PublicSimulatorConfig &config)
Definition simulation_helper.cpp:634

bb::avm2::AvmSimulationHelper::simulate_fast_with_existing_ws
TxSimulationResult simulate_fast_with_existing_ws(simulation::ContractDBInterface &raw_contract_db, const world_state::WorldStateRevision &world_state_revision, world_state::WorldState &ws, const PublicSimulatorConfig &config, const Tx &tx, const GlobalVariables &global_variables, const ProtocolContracts &protocol_contracts, simulation::CancellationTokenPtr cancellation_token=nullptr)
Definition simulation_helper.cpp:559

bb::avm2::AvmSimulationHelper::simulate_for_witgen
simulation::EventsContainer simulate_for_witgen(const ExecutionHints &hints)
Definition simulation_helper.cpp:617

bb::avm2::address_derivation
Definition address_derivation.hpp:33

bb::avm2::alu
Definition alu.hpp:36

bb::avm2::bitwise
Definition bitwise.hpp:35

bb::avm2::class_id_derivation
Definition class_id_derivation.hpp:33

bb::avm2::data_copy
Definition data_copy.hpp:35

bb::avm2::ecc
Definition ecc.hpp:34

bb::avm2::execution
Definition execution.hpp:37

bb::avm2::get_contract_instance
Definition get_contract_instance.hpp:33

bb::avm2::indexed_tree_check
Definition indexed_tree_check.hpp:34

bb::avm2::keccakf1600
Definition keccakf1600.hpp:38

bb::avm2::merkle_check
Definition merkle_check.hpp:34

bb::avm2::note_hash_tree_check
Definition note_hash_tree_check.hpp:34

bb::avm2::range_check
Definition range_check.hpp:34

bb::avm2::sha256
Definition sha256.hpp:37

bb::avm2::simulation::AddressDerivation
Definition address_derivation.hpp:13

bb::avm2::simulation::Alu
Definition alu.hpp:13

bb::avm2::simulation::Bitwise
Witness-generating implementation of bitwise AND/OR/XOR operations.
Definition bitwise.hpp:13

bb::avm2::simulation::BytecodeHasher
Definition bytecode_hashing.hpp:14

bb::avm2::simulation::CalldataHashingProvider
Definition calldata_hashing.hpp:31

bb::avm2::simulation::ClassIdDerivation
Definition class_id_derivation.hpp:12

bb::avm2::simulation::ContextProvider
Definition context_provider.hpp:23

bb::avm2::simulation::ContractDB
Definition concrete_dbs.hpp:18

bb::avm2::simulation::ContractDBInterface
Definition db.hpp:17

bb::avm2::simulation::ContractInstanceManager
Definition contract_instance_manager.hpp:16

bb::avm2::simulation::DataCopy
Definition data_copy.hpp:15

bb::avm2::simulation::Ecc
Definition ecc.hpp:15

bb::avm2::simulation::EmitPublicLog
Definition emit_public_log.hpp:18

bb::avm2::simulation::ExecutionComponentsProvider
Definition execution_components.hpp:13

bb::avm2::simulation::Execution
Definition execution.hpp:50

bb::avm2::simulation::ExecutionIdManager
Definition execution_id_manager.hpp:20

bb::avm2::simulation::FieldGreaterThan
Definition field_gt.hpp:11

bb::avm2::simulation::GetContractInstance
Definition get_contract_instance.hpp:17

bb::avm2::simulation::GreaterThan
Definition gt.hpp:14

bb::avm2::simulation::HintedRawContractDB
Definition raw_data_dbs.hpp:26

bb::avm2::simulation::HintedRawMerkleDB
Definition raw_data_dbs.hpp:57

bb::avm2::simulation::HintingContractsDB
Definition hinting_dbs.hpp:22

bb::avm2::simulation::HintingRawDB
Definition hinting_dbs.hpp:53

bb::avm2::simulation::HybridExecution
Definition hybrid_execution.hpp:11

bb::avm2::simulation::IndexedTreeCheck
Definition indexed_tree_check.hpp:19

bb::avm2::simulation::InstructionInfoDB
Definition instruction_info.hpp:19

bb::avm2::simulation::InternalCallStackManagerProvider
Definition internal_call_stack_manager.hpp:47

bb::avm2::simulation::KeccakF1600
Definition keccakf1600.hpp:49

bb::avm2::simulation::L1ToL2MessageTreeCheck
Definition l1_to_l2_message_tree_check.hpp:15

bb::avm2::simulation::LowLevelMerkleDBInterface
Definition db.hpp:45

bb::avm2::simulation::MemoryProvider
Definition memory.hpp:47

bb::avm2::simulation::MerkleCheck
Definition merkle_check.hpp:14

bb::avm2::simulation::MerkleDB
Definition concrete_dbs.hpp:58

bb::avm2::simulation::NoopCalldataHashingProvider
Definition noop_calldata_hashing.hpp:12

bb::avm2::simulation::NoopDebugLogger
Definition debug_log.hpp:8

bb::avm2::simulation::NoopDebugLogger::dump_logs
std::vector< DebugLog > dump_logs() override
Definition debug_log.hpp:19

bb::avm2::simulation::NoopEventEmitter
Definition event_emitter.hpp:59

bb::avm2::simulation::NoopUpdateCheck
Definition noop_update_check.hpp:7

bb::avm2::simulation::NoteHashTreeCheck
Definition note_hash_tree_check.hpp:18

bb::avm2::simulation::Poseidon2
Definition poseidon2.hpp:17

bb::avm2::simulation::PublicDataTreeCheck
Definition public_data_tree_check.hpp:21

bb::avm2::simulation::PublicDataTreeCheck::generate_ff_gt_events_for_squashing
void generate_ff_gt_events_for_squashing(const std::vector< FF > &written_leaf_slots)
Generates ff_gt events for squashing.
Definition public_data_tree_check.cpp:234

bb::avm2::simulation::PublicInputsBuilder
Definition public_inputs_builder.hpp:10

bb::avm2::simulation::PublicInputsBuilder::extract_inputs
PublicInputsBuilder & extract_inputs(const Tx &tx, const GlobalVariables &global_variables, const ProtocolContracts &protocol_contracts, const FF &prover_id, const LowLevelMerkleDBInterface &merkle_db)
Definition public_inputs_builder.cpp:7

bb::avm2::simulation::PureAlu
Definition pure_alu.hpp:8

bb::avm2::simulation::PureBitwise
Definition pure_bitwise.hpp:9

bb::avm2::simulation::PureContractDB
Definition concrete_dbs.hpp:15

bb::avm2::simulation::PureExecutionComponentsProvider
Definition pure_execution_components.hpp:12

bb::avm2::simulation::PureGreaterThan
Definition pure_gt.hpp:12

bb::avm2::simulation::PureKeccakF1600
Definition pure_keccakf1600.hpp:7

bb::avm2::simulation::PureMemoryProvider
Definition pure_memory.hpp:36

bb::avm2::simulation::PureMerkleDB
Definition concrete_dbs.hpp:38

bb::avm2::simulation::PurePoseidon2
Definition pure_poseidon2.hpp:9

bb::avm2::simulation::PureRawMerkleDB
Definition raw_data_dbs.hpp:115

bb::avm2::simulation::PureRawMerkleDB::get_tree_roots
TreeSnapshots get_tree_roots() const override
Definition raw_data_dbs.cpp:684

bb::avm2::simulation::PureSha256
Definition pure_sha256.hpp:7

bb::avm2::simulation::PureToRadix
Definition pure_to_radix.hpp:13

bb::avm2::simulation::PureTxBytecodeManager
Definition pure_bytecode_manager.hpp:23

bb::avm2::simulation::PureWrittenPublicDataSlotsTreeCheck
Definition written_public_data_slots_tree_check.hpp:16

bb::avm2::simulation::RangeCheck
Definition range_check.hpp:11

bb::avm2::simulation::RetrievedBytecodesTreeCheck
Definition retrieved_bytecodes_tree_check.hpp:13

bb::avm2::simulation::Sha256
Definition sha256.hpp:17

bb::avm2::simulation::SideEffectTracker
Definition side_effect_tracker.hpp:47

bb::avm2::simulation::SideEffectTracker::get_side_effects
const TrackedSideEffects & get_side_effects() const override
Definition side_effect_tracker.hpp:61

bb::avm2::simulation::SideEffectTrackerInterface
Interface for a side effect tracker.
Definition side_effect_tracker.hpp:29

bb::avm2::simulation::SideEffectTrackingDB
A high-level merkle db that tracks side effects.
Definition side_effect_tracking_db.hpp:16

bb::avm2::simulation::ToRadix
Definition to_radix.hpp:18

bb::avm2::simulation::TxBytecodeManager
Definition bytecode_manager.hpp:26

bb::avm2::simulation::TxExecution
Definition tx_execution.hpp:34

bb::avm2::simulation::UpdateCheck
Definition update_check.hpp:14

bb::avm2::simulation::WrittenPublicDataSlotsTreeCheck
Definition written_public_data_slots_tree_check.hpp:15

bb::avm2::to_radix
Definition to_radix.hpp:35

bb::avm2::tx
Definition tx.hpp:36

bb::avm2::update_check
Definition update_check.hpp:34

bb::crypto::Poseidon2< crypto::Poseidon2Bn254ScalarFieldParams >

bb::world_state::WorldState
Holds the Merkle trees responsible for storing the state of the Aztec protocol.
Definition world_state.hpp:59

log.hpp

execution_id_manager
ExecutionIdManager execution_id_manager
Definition data_copy.test.cpp:51

value
FF value
Definition indexed_tree_check.test.cpp:69

contract_instance_retrieval_event.hpp

db.hpp

db_types.hpp

ecc_events.hpp

event_emitter.hpp

execution_event.hpp

execution_id_manager.hpp

field_gt_event.hpp

bytecode_manager.hpp

concrete_dbs.hpp

contract_instance_manager.hpp

execution_components.hpp

field_gt.hpp

internal_call_stack_manager.hpp

written_public_data_slots_tree_check.hpp

instruction_info_db
InstructionInfoDB instruction_info_db
Definition gas_tracker.test.cpp:30

get_contract_instance_event.hpp

hinting_dbs.hpp

hinting_contract_db
HintingContractsDB hinting_contract_db
Definition hinting_dbs.test.cpp:48

base_merkle_db
HintedRawMerkleDB base_merkle_db
Definition hinting_dbs.test.cpp:47

hinting_merkle_db
HintingRawDB hinting_merkle_db
Definition hinting_dbs.test.cpp:49

hybrid_execution.hpp

indexed_tree_check_event.hpp

instruction_info.hpp

keccakf1600_event.hpp

call_stack_metadata_collector.hpp

memory_event.hpp

merkle_check_event.hpp

bb::avm2::simulation
AVM range check gadget for witness generation.
Definition address_derivation_event.hpp:6

bb::avm2::simulation::poseidon2
crypto::Poseidon2< crypto::Poseidon2Bn254ScalarFieldParams > poseidon2
Definition contract_crypto.cpp:9

bb::avm2::simulation::build_retrieved_bytecodes_tree
RetrievedBytecodesTree build_retrieved_bytecodes_tree()
Definition retrieved_bytecodes_tree.cpp:58

bb::avm2::simulation::CancellationTokenPtr
std::shared_ptr< CancellationToken > CancellationTokenPtr
Definition cancellation_token.hpp:79

bb::avm2::simulation::build_public_data_slots_tree
WrittenPublicDataSlotsTree build_public_data_slots_tree()
Definition written_slots_tree.cpp:58

bb::avm2
Definition dbs.cpp:19

bb::avm2::DebugLogLevel
DebugLogLevel
Definition aztec_types.hpp:536

bb::avm2::DebugLogLevel::INFO
@ INFO

bb::avm2::RevertCode::OK
@ OK

std::get
constexpr decltype(auto) get(::tuplet::tuple< T... > &&t) noexcept
Definition tuple.hpp:13

noop_calldata_hashing.hpp

noop_update_check.hpp

slot
FF slot
Definition public_data_tree.test.cpp:96

public_data_tree_check_event.hpp

pure_alu.hpp

pure_bitwise.hpp

pure_bytecode_manager.hpp

pure_execution_components.hpp

pure_gt.hpp

pure_keccakf1600.hpp

pure_memory.hpp

pure_poseidon2.hpp

pure_sha256.hpp

pure_to_radix.hpp

range_check_event.hpp

raw_data_dbs.hpp

sha256_event.hpp

side_effect_tracker.hpp

side_effect_tracking_db.hpp

update_check.hpp

addressing.hpp

alu.hpp

bitwise.hpp

calldata_hashing.hpp

context.hpp

data_copy.hpp

ecc.hpp

emit_public_log.hpp

execution.hpp

get_contract_instance.hpp

gt.hpp

keccakf1600.hpp

memory.hpp

merkle_check.hpp

range_check.hpp

to_radix.hpp

update_check.hpp

update_check.hpp

public_inputs_builder.hpp

simulation_helper.hpp

concrete_dbs.hpp

written_public_data_slots_tree_check.hpp

bb::avm2::CollectionLimitsConfig::max_debug_log_memory_reads
uint32_t max_debug_log_memory_reads
Definition avm_io.hpp:428

bb::avm2::ExecutionHints
Definition avm_io.hpp:358

bb::avm2::ExecutionHints::global_variables
GlobalVariables global_variables
Definition avm_io.hpp:359

bb::avm2::ExecutionHints::tx
Tx tx
Definition avm_io.hpp:360

bb::avm2::ExecutionHints::protocol_contracts
ProtocolContracts protocol_contracts
Definition avm_io.hpp:362

bb::avm2::GasUsed::billed_gas
Gas billed_gas
Definition aztec_types.hpp:333

bb::avm2::GlobalVariables
Definition aztec_types.hpp:466

bb::avm2::ProtocolContracts
Definition aztec_types.hpp:590

bb::avm2::PublicDataWrite
Definition aztec_types.hpp:295

bb::avm2::PublicDataWrite::leaf_slot
FF leaf_slot
Definition aztec_types.hpp:296

bb::avm2::PublicSimulatorConfig
Definition avm_io.hpp:443

bb::avm2::PublicSimulatorConfig::collect_hints
bool collect_hints
Definition avm_io.hpp:447

bb::avm2::PublicSimulatorConfig::collect_call_metadata
bool collect_call_metadata
Definition avm_io.hpp:446

bb::avm2::PublicSimulatorConfig::collect_debug_logs
bool collect_debug_logs
Definition avm_io.hpp:449

bb::avm2::PublicSimulatorConfig::collect_public_inputs
bool collect_public_inputs
Definition avm_io.hpp:448

bb::avm2::PublicSimulatorConfig::prover_id
FF prover_id
Definition avm_io.hpp:444

bb::avm2::PublicSimulatorConfig::skip_fee_enforcement
bool skip_fee_enforcement
Definition avm_io.hpp:445

bb::avm2::PublicSimulatorConfig::collection_limits
CollectionLimitsConfig collection_limits
Definition avm_io.hpp:451

bb::avm2::PublicTxEffect
Definition avm_io.hpp:535

bb::avm2::PublicTxEffect::note_hashes
std::vector< FF > note_hashes
Definition avm_io.hpp:537

bb::avm2::PublicTxEffect::public_logs
std::vector< PublicLog > public_logs
Definition avm_io.hpp:540

bb::avm2::PublicTxEffect::nullifiers
std::vector< FF > nullifiers
Definition avm_io.hpp:538

bb::avm2::PublicTxEffect::transaction_fee
FF transaction_fee
Definition avm_io.hpp:536

bb::avm2::PublicTxEffect::public_data_writes
std::vector< PublicDataWrite > public_data_writes
Definition avm_io.hpp:541

bb::avm2::PublicTxEffect::l2_to_l1_msgs
std::vector< ScopedL2ToL1Message > l2_to_l1_msgs
Definition avm_io.hpp:539

bb::avm2::Tx
Definition avm_io.hpp:329

bb::avm2::TxSimulationResult
Definition avm_io.hpp:548

bb::avm2::TxSimulationResult::gas_used
GasUsed gas_used
Definition avm_io.hpp:550

bb::avm2::simulation::EventsContainer
Definition events_container.hpp:36

bb::avm2::simulation::TxExecutionResult
Definition tx_execution.hpp:27

bb::avm2::simulation::TxExecutionResult::gas_used
GasUsed gas_used
Definition tx_execution.hpp:28

bb::avm2::simulation::TxExecutionResult::transaction_fee
FF transaction_fee
Definition tx_execution.hpp:30

bb::avm2::simulation::TxExecutionResult::revert_code
RevertCode revert_code
Definition tx_execution.hpp:29

bb::world_state::WorldStateRevision
Definition types.hpp:35

to_radix_event.hpp

public_inputs_builder
tracegen::PublicInputsTraceBuilder public_inputs_builder
Definition tx.test.cpp:81

tx_events.hpp

tx_execution.hpp

side_effect_tracker
SideEffectTracker side_effect_tracker
Definition tx_execution.test.cpp:39

tx_execution
TxExecution tx_execution
Definition tx_execution.test.cpp:41

context_provider
NiceMock< MockContextProvider > context_provider
Definition tx_execution.test.cpp:30

call_stack_metadata_collector
NoopCallStackMetadataCollector call_stack_metadata_collector
Definition tx_execution.test.cpp:40

tx_event_emitter
EventEmitter< TxEvent > tx_event_emitter
Definition tx_execution.test.cpp:31

written_public_data_slots_tree_check
NiceMock< MockWrittenPublicDataSlotsTreeCheck > written_public_data_slots_tree_check
Definition tx_execution.test.cpp:37

field.hpp

poseidon2.hpp

sha256.hpp

debug_log.hpp

debug_log.hpp