feat: merge-train/avm (#19197)

BEGIN_COMMIT_OVERRIDE
feat(avm): tx<>prover fuzzer (#19134)
END_COMMIT_OVERRIDE

Author: defkit

barretenberg/cpp/CMakeLists.txt

@@ -28,6 +28,7 @@ option(OMP_MULTITHREADING "Enable OMP multi-threading" OFF)
 option(FUZZING "Build ONLY fuzzing harnesses" OFF)
 option(ENABLE_PAR_ALGOS "Enable parallel algorithms" OFF)
 option(COVERAGE "Enable collecting coverage from tests" OFF)
+option(COVERAGE_AVM "Enable coverage filtered to AVM code only" OFF)
 option(ENABLE_ASAN "Address sanitizer for debugging tricky memory corruption" OFF)
 option(ENABLE_HEAVY_TESTS "Enable heavy tests when collecting coverage" OFF)
 # Note: Must do 'sudo apt-get install libdw-dev' or equivalent
@@ -74,6 +75,10 @@ if(ENABLE_ASAN)
     set(DISABLE_ASM ON)
 endif()
 
+if(COVERAGE_AVM)
+    add_compile_options(-DCOVERAGE_AVM)
+endif()
+
 if(FUZZING)
     add_definitions(-DULTRA_FUZZ)
     if(FUZZING_SHOW_INFORMATION)

barretenberg/cpp/src/barretenberg/avm_fuzzer/common/interfaces/dbs.cpp

@@ -3,189 +3,21 @@
 #include <cstdint>
 #include <vector>
 
+#include "barretenberg/avm_fuzzer/fuzz_lib/constants.hpp"
 #include "barretenberg/common/throw_or_abort.hpp"
 #include "barretenberg/crypto/merkle_tree/indexed_tree/indexed_leaf.hpp"
 #include "barretenberg/crypto/poseidon2/poseidon2.hpp"
 #include "barretenberg/vm2/common/aztec_constants.hpp"
 #include "barretenberg/vm2/common/aztec_types.hpp"
+#include "barretenberg/vm2/simulation/lib/contract_crypto.hpp"
+#include "barretenberg/vm2/simulation/lib/merkle.hpp"
 
 using namespace bb::avm2::simulation;
 using Poseidon2 = bb::crypto::Poseidon2<bb::crypto::Poseidon2Bn254ScalarFieldParams>;
-using namespace bb::crypto::merkle_tree;
 using namespace bb::world_state;
 
-// TODO(ilyas): implement other methods as needed
 namespace bb::avm2::fuzzer {
 
-TreeSnapshots FuzzerLowLevelDB::get_tree_roots() const
-{
-    return {
-        .l1_to_l2_message_tree = { .root = FF(0), .next_available_leaf_index = 0 },
-        .note_hash_tree = { .root = FF(0), .next_available_leaf_index = next_available_note_hash_index },
-        .nullifier_tree = { .root = FF(0), .next_available_leaf_index = next_available_nullifier_index },
-        .public_data_tree = { .root = FF(0), .next_available_leaf_index = next_available_public_data_index },
-    };
-}
-
-SiblingPath FuzzerLowLevelDB::get_sibling_path([[maybe_unused]] MerkleTreeId tree_id,
-                                               [[maybe_unused]] index_t leaf_index) const
-{
-    throw_or_abort("FuzzerLowLevelDB::get_sibling_path not implemented");
-}
-
-std::pair<FF, index_t> FuzzerLowLevelDB::get_indexed_low_leaf_helper(
-    const std::vector<std::pair<FF, index_t>>& value_sorted_leaves, const FF& value) const
-{
-    for (size_t i = 0; i < value_sorted_leaves.size(); ++i) {
-        if (value_sorted_leaves[i].first == value) {
-            return value_sorted_leaves[i];
-        }
-        if (value_sorted_leaves[i].first > value) {
-            return value_sorted_leaves[i - 1];
-        }
-    }
-    // If we reach here, the value is larger than any leaf in the tree, return the last leaf
-    return value_sorted_leaves.back();
-}
-
-GetLowIndexedLeafResponse FuzzerLowLevelDB::get_low_indexed_leaf(MerkleTreeId tree_id, const FF& value) const
-{
-    switch (tree_id) {
-    case MerkleTreeId::NULLIFIER_TREE: {
-        auto [low_value, low_index] = get_indexed_low_leaf_helper(nullifier_values, value);
-        return GetLowIndexedLeafResponse(low_value == value, low_index);
-        break;
-    }
-    case MerkleTreeId::PUBLIC_DATA_TREE: {
-        auto [low_value, low_index] = get_indexed_low_leaf_helper(public_data_slots, value);
-        return GetLowIndexedLeafResponse(low_value == value, low_index);
-        break;
-    }
-    default:
-        break;
-    }
-    return GetLowIndexedLeafResponse(false, 0);
-}
-FF FuzzerLowLevelDB::get_leaf_value(MerkleTreeId tree_id, index_t leaf_index) const
-{
-    switch (tree_id) {
-    case MerkleTreeId::NULLIFIER_TREE:
-        return nullifier_leaves.at(leaf_index).nullifier;
-    case MerkleTreeId::PUBLIC_DATA_TREE:
-        return public_data_leaves.at(leaf_index).value;
-    case MerkleTreeId::NOTE_HASH_TREE:
-        return note_hash_leaves.at(leaf_index);
-    default:
-        break;
-    }
-    return FF(0);
-}
-simulation::IndexedLeaf<PublicDataLeafValue> FuzzerLowLevelDB::get_leaf_preimage_public_data_tree(
-    index_t leaf_index) const
-{
-    PublicDataLeafValue leaf_value = public_data_leaves.at(leaf_index);
-    std::pair<FF, index_t> value_index_pair = { leaf_value.value, leaf_index };
-    // Find index in public_data_slots
-    auto it = std::ranges::find_if(
-        public_data_slots.begin(), public_data_slots.end(), [&value_index_pair](const std::pair<FF, index_t>& pair) {
-            return pair.second == value_index_pair.second;
-        });
-    if (it == public_data_slots.end()) {
-        throw_or_abort("FuzzerLowLevelDB::get_leaf_preimage_public_data_tree: leaf not found in public_data_slots");
-    }
-    it++; // Now iterator is at the next element
-    if (it == public_data_slots.end()) {
-        // If this is the last leaf, return with index 0
-        return simulation::IndexedLeaf<PublicDataLeafValue>(leaf_value, 0, 0);
-    }
-    auto [next_value, next_index] = *it;
-    return bb::crypto::merkle_tree::IndexedLeaf<PublicDataLeafValue>(leaf_value, next_index, next_value);
-}
-
-simulation::IndexedLeaf<NullifierLeafValue> FuzzerLowLevelDB::get_leaf_preimage_nullifier_tree(index_t leaf_index) const
-{
-    auto leaf_value = nullifier_leaves.at(leaf_index);
-    std::pair<FF, index_t> value_index_pair = { leaf_value.nullifier, leaf_index };
-    // Find index in nullifiers_values
-    auto it = std::ranges::find_if(
-        nullifier_values.begin(), nullifier_values.end(), [&value_index_pair](const std::pair<FF, index_t>& pair) {
-            return pair.second == value_index_pair.second;
-        });
-    if (it == nullifier_values.end()) {
-        throw_or_abort("FuzzerLowLevelDB::get_leaf_preimage_nullifier_tree: leaf not found in nullifier_values");
-    }
-
-    it++; // Now iterator is at the next element
-
-    if (it == nullifier_values.end()) {
-        // If this is the last leaf, return with index 0
-        return simulation::IndexedLeaf<NullifierLeafValue>(leaf_value, 0, 0);
-    }
-    auto [next_value, next_index] = *it;
-    return simulation::IndexedLeaf<NullifierLeafValue>(leaf_value, next_index, next_value);
-}
-
-simulation::SequentialInsertionResult<PublicDataLeafValue> FuzzerLowLevelDB::insert_indexed_leaves_public_data_tree(
-    const PublicDataLeafValue& leaf_value)
-{
-    // Add to map
-    public_data_leaves[next_available_public_data_index] = leaf_value;
-    // Add to sorted vector
-    public_data_slots.push_back({ leaf_value.slot, next_available_public_data_index });
-    // Sort vector
-    std::ranges::sort(
-        public_data_slots.begin(),
-        public_data_slots.end(),
-        [](const std::pair<FF, index_t>& a, const std::pair<FF, index_t>& b) { return a.first < b.first; });
-
-    // Increment next available index
-    next_available_public_data_index++;
-    // Don't return any witness data for now, as it's not used for pure calls.
-    return {};
-}
-
-simulation::SequentialInsertionResult<NullifierLeafValue> FuzzerLowLevelDB::insert_indexed_leaves_nullifier_tree(
-    const NullifierLeafValue& leaf_value)
-{
-    // Add to map
-    nullifier_leaves[next_available_nullifier_index] = leaf_value;
-    // Add to sorted vector
-    nullifier_values.push_back({ leaf_value.nullifier, next_available_nullifier_index });
-    // Sort vector
-    std::ranges::sort(
-        nullifier_values.begin(),
-        nullifier_values.end(),
-        [](const std::pair<FF, index_t>& a, const std::pair<FF, index_t>& b) { return a.first < b.first; });
-
-    // Increment next available index
-    next_available_nullifier_index++;
-    // Don't return any witness data for now, as it's not used for pure calls.
-    return {};
-}
-
-void FuzzerLowLevelDB::append_leaves([[maybe_unused]] MerkleTreeId tree_id, std::span<const FF> leaves)
-{
-    note_hash_leaves.insert(note_hash_leaves.end(), leaves.begin(), leaves.end());
-    next_available_note_hash_index += leaves.size();
-}
-void FuzzerLowLevelDB::pad_tree([[maybe_unused]] MerkleTreeId tree_id, [[maybe_unused]] size_t num_leaves) {}
-
-void FuzzerLowLevelDB::create_checkpoint() {}
-void FuzzerLowLevelDB::commit_checkpoint() {}
-void FuzzerLowLevelDB::revert_checkpoint() {}
-uint32_t FuzzerLowLevelDB::get_checkpoint_id() const
-{
-    return 0;
-}
-
-// Helper to insert a contract address into the nullifier tree
-void FuzzerLowLevelDB::insert_contract_address(const AztecAddress& contract_address)
-{
-    auto contract_nullifier =
-        simulation::unconstrained_silo_nullifier(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS, contract_address);
-    insert_indexed_leaves_nullifier_tree(contract_nullifier);
-}
-
 ////////////////////////////////
 /// ContractDBInterface methods
 ////////////////////////////////
@@ -207,13 +39,12 @@ std::optional<ContractClass> FuzzerContractDB::get_contract_class(const Contract
 
 std::optional<FF> FuzzerContractDB::get_bytecode_commitment(const ContractClassId& class_id) const
 {
-    // Return 0 might be an issue, in the pure bytecode manager we cache based on this value
-    // This might cause different classes to be treated as the same if they return 0 here.
-    // For now we just return the class_id as it should be as unique as the bytecode commitment
     if (!contract_classes.contains(class_id)) {
         return std::nullopt;
     }
-    return class_id;
+    // Compute the actual bytecode commitment from the stored bytecode
+    const auto& klass = contract_classes.at(class_id);
+    return compute_public_bytecode_commitment(klass.packed_bytecode);
 }
 std::optional<std::string> FuzzerContractDB::get_debug_function_name(
     [[maybe_unused]] const AztecAddress& address, [[maybe_unused]] const FunctionSelector& selector) const
@@ -239,12 +70,21 @@ void FuzzerContractDB::add_contracts(const ContractDeploymentData& contract_depl
 
 void FuzzerContractDB::add_contract_class(const ContractClassId& class_id, const ContractClass& contract_class)
 {
-    contract_classes[class_id] = contract_class;
+    // todo(ilyas): think of a nicer way without both map and vector
+    // Only push to vector if not already present, otherwise we get duplicates sent to the TS simulator
+    if (contract_classes.contains(class_id)) {
+        return;
+    }
     contract_classes_vector.push_back(contract_class);
+    contract_classes[class_id] = contract_class;
 }
 
 void FuzzerContractDB::add_contract_instance(const AztecAddress& address, const ContractInstance& contract_instance)
 {
+    // todo(ilyas): think of a nicer way without both map and vector
+    if (contract_instances.contains(address)) {
+        return;
+    }
     contract_instances[address] = contract_instance;
     contract_instances_vector.push_back({ address, contract_instance });
 }
@@ -379,6 +219,7 @@ void FuzzerWorldStateManager::register_contract_address(const AztecAddress& cont
 {
     NullifierLeafValue contract_nullifier =
         unconstrained_silo_nullifier(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS, contract_address);
+    fuzz_info("Registering contract address in world state: ", contract_nullifier.nullifier);
     auto fork_id = fork_ids.top();
     ws->insert_indexed_leaves<NullifierLeafValue>(MerkleTreeId::NULLIFIER_TREE, { contract_nullifier }, fork_id);
 }

barretenberg/cpp/src/barretenberg/avm_fuzzer/common/interfaces/dbs.hpp

@@ -1,67 +1,15 @@
 #pragma once
 
+#include <memory>
 #include <stack>
 
 #include "barretenberg/vm2/common/aztec_types.hpp"
 #include "barretenberg/vm2/simulation/interfaces/db.hpp"
-#include "barretenberg/vm2/simulation/lib/merkle.hpp"
 #include "barretenberg/world_state/types.hpp"
 #include "barretenberg/world_state/world_state.hpp"
-#include <memory>
-#include <stack>
 
 namespace bb::avm2::fuzzer {
 
-// FIXME(ilyas): This is now unused for the fuzzer, but I have a plan to experiment with this later.
-class FuzzerLowLevelDB : public bb::avm2::simulation::LowLevelMerkleDBInterface {
-  public:
-    TreeSnapshots get_tree_roots() const override;
-
-    simulation::SiblingPath get_sibling_path(simulation::MerkleTreeId tree_id, index_t leaf_index) const override;
-
-    GetLowIndexedLeafResponse get_low_indexed_leaf(simulation::MerkleTreeId tree_id, const FF& value) const override;
-
-    FF get_leaf_value(simulation::MerkleTreeId tree_id, index_t leaf_index) const override;
-
-    simulation::IndexedLeaf<PublicDataLeafValue> get_leaf_preimage_public_data_tree(index_t leaf_index) const override;
-
-    simulation::IndexedLeaf<NullifierLeafValue> get_leaf_preimage_nullifier_tree(index_t leaf_index) const override;
-
-    simulation::SequentialInsertionResult<PublicDataLeafValue> insert_indexed_leaves_public_data_tree(
-        const PublicDataLeafValue& leaf_value) override;
-
-    simulation::SequentialInsertionResult<NullifierLeafValue> insert_indexed_leaves_nullifier_tree(
-        const NullifierLeafValue& leaf_value) override;
-
-    void append_leaves(simulation::MerkleTreeId tree_id, std::span<const FF> leaves) override;
-
-    void pad_tree(simulation::MerkleTreeId tree_id, size_t num_leaves) override;
-    void create_checkpoint() override;
-    void commit_checkpoint() override;
-    void revert_checkpoint() override;
-    uint32_t get_checkpoint_id() const override;
-
-    // Some helper functions for the fuzzer to use
-    void insert_contract_address(const AztecAddress& contract_address);
-
-  private:
-    std::pair<FF, index_t> get_indexed_low_leaf_helper(const std::vector<std::pair<FF, index_t>>& value_sorted_leaves,
-                                                       const FF& value) const;
-
-    // Stored leaves sorted by value/slots for low-indexed leaf retrieval
-    std::vector<std::pair<FF, index_t>> nullifier_values{ { 0, 0 } };
-    std::vector<std::pair<FF, index_t>> public_data_slots{ { 0, 0 } };
-    // Stored leaves with their indices
-    std::unordered_map<index_t, NullifierLeafValue> nullifier_leaves{ { 0, NullifierLeafValue(0) } };
-    std::unordered_map<index_t, PublicDataLeafValue> public_data_leaves{ { 0, PublicDataLeafValue(0, 0) } };
-    std::vector<FF> note_hash_leaves;
-
-    // Indices
-    uint64_t next_available_nullifier_index = 1;
-    uint64_t next_available_public_data_index = 1;
-    uint64_t next_available_note_hash_index = 0;
-};
-
 class FuzzerContractDB : public simulation::ContractDBInterface {
   public:
     FuzzerContractDB() = default;