simulator.hpp

Go to the documentation of this file.

#pragma once
 
#include <vector>
 
#include "barretenberg/avm_fuzzer/common/interfaces/dbs.hpp"
#include "barretenberg/avm_fuzzer/common/process.hpp"
#include "barretenberg/crypto/merkle_tree/indexed_tree/indexed_leaf.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/execution.hpp"
 
using namespace bb::avm2::simulation;
using namespace bb::avm2;
 
struct FuzzerSimulationRequest {
    std::string ws_data_dir;
    uint64_t ws_map_size_kb;
    Tx tx;
    GlobalVariables globals;
    std::vector<ContractClass> contract_classes;
    // Having addresses here avoids doing re-work in TS.
    std::vector<std::pair<AztecAddress, ContractInstance>> contract_instances;
    // Public data tree writes to apply before simulation (e.g., for bytecode upgrades)
    std::vector<bb::crypto::merkle_tree::PublicDataLeafValue> public_data_writes;
    // Note hashes to be applied before simulation
    std::vector<FF> note_hashes;
    // Protocol contracts mapping (canonical address index -> derived address)
    ProtocolContracts protocol_contracts;
 
    MSGPACK_CAMEL_CASE_FIELDS(ws_data_dir,
                              ws_map_size_kb,
                              tx,
                              globals,
                              contract_classes,
                              contract_instances,
                              public_data_writes,
                              note_hashes,
                              protocol_contracts);
};
 
struct SimulatorResult {
    bool reverted;
    std::vector<FF> output;
    TreeSnapshots end_tree_snapshots;
    std::string revert_reason;
    PublicTxEffect public_tx_effect;
 
    MSGPACK_CAMEL_CASE_FIELDS(reverted, output, end_tree_snapshots, revert_reason, public_tx_effect);
};
 
class Simulator {
  public:
    virtual ~Simulator() = default;
    Simulator(const Simulator&) = delete;
    Simulator& operator=(const Simulator&) = delete;
    Simulator(Simulator&&) = delete;
    Simulator& operator=(Simulator&&) = delete;
    Simulator() = default;
    virtual SimulatorResult simulate(
        fuzzer::FuzzerWorldStateManager& ws_mgr,
        fuzzer::FuzzerContractDB& contract_db,
        const Tx& tx,
        const GlobalVariables& globals,
        const std::vector<bb::crypto::merkle_tree::PublicDataLeafValue>& public_data_writes,
        const std::vector<FF>& note_hashes,
        const ProtocolContracts& protocol_contracts) = 0;
};
 
class CppSimulator : public Simulator {
  public:
    SimulatorResult simulate(fuzzer::FuzzerWorldStateManager& ws_mgr,
                             fuzzer::FuzzerContractDB& contract_db,
                             const Tx& tx,
                             const GlobalVariables& globals,
                             const std::vector<bb::crypto::merkle_tree::PublicDataLeafValue>& public_data_writes,
                             const std::vector<FF>& note_hashes,
                             const ProtocolContracts& protocol_contracts) override;
};
 
class JsSimulator : public Simulator {
  protected:
    static JsSimulator* instance;
    std::string simulator_path;
    JsSimulator(std::string& simulator_path);
    Process process;
 
  public:
    JsSimulator(JsSimulator& other) = delete;
    void operator=(const JsSimulator&) = delete;
    JsSimulator(JsSimulator&&) = delete;
    JsSimulator& operator=(JsSimulator&&) = delete;
    ~JsSimulator() = default;
 
    static JsSimulator* getInstance();
    static void initialize(std::string& simulator_path);
 
    SimulatorResult simulate(fuzzer::FuzzerWorldStateManager& ws_mgr,
                             fuzzer::FuzzerContractDB& contract_db,
                             const Tx& tx,
                             const GlobalVariables& globals,
                             const std::vector<bb::crypto::merkle_tree::PublicDataLeafValue>& public_data_writes,
                             const std::vector<FF>& note_hashes,
                             const ProtocolContracts& protocol_contracts) override;
};
 
GlobalVariables create_default_globals();
 
Tx create_default_tx(const AztecAddress& contract_address,
                     const AztecAddress& sender_address,
                     const std::vector<FF>& calldata,
                     [[maybe_unused]] const FF& transaction_fee,
                     bool is_static_call,
                     const Gas& gas_limit);
 
bool compare_simulator_results(SimulatorResult& result1, SimulatorResult& result2);