feat: remake db getters const, add temp ref structs, cleanup

Author: MirandaWood

barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/concrete_dbs.cpp

@@ -7,7 +7,7 @@
 namespace bb::avm2::simulation {
 
 // Contracts DB starts.
-std::optional<ContractInstance> ContractDB::get_contract_instance(const AztecAddress& address)
+std::optional<ContractInstance> ContractDB::get_contract_instance(const AztecAddress& address) const
 {
     std::optional<ContractInstance> instance = raw_contract_db.get_contract_instance(address);
     // If we didn't get a contract instance, we don't prove anything.
@@ -26,7 +26,7 @@ std::optional<ContractInstance> ContractDB::get_contract_instance(const AztecAdd
     return instance;
 }
 
-std::optional<ContractClass> ContractDB::get_contract_class(const ContractClassId& class_id)
+std::optional<ContractClass> ContractDB::get_contract_class(const ContractClassId& class_id) const
 {
     std::optional<ContractClass> klass = raw_contract_db.get_contract_class(class_id);
     // If we didn't get a contract class, we don't prove anything.

barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/concrete_dbs.hpp

@@ -30,11 +30,11 @@ class ContractDB final : public ContractDBInterface {
     // Gets an instance from the DB and proves address derivation from the result.
     // This does NOT prove that the address is in the nullifier tree.
     // Silo the address and use the MerkleDB to prove that.
-    std::optional<ContractInstance> get_contract_instance(const AztecAddress& address) override;
+    std::optional<ContractInstance> get_contract_instance(const AztecAddress& address) const override;
     // Gets a class from the DB and proves class id derivation from the result.
     // This does NOT prove that the class id is in the nullifier tree.
     // Silo the class id and use the MerkleDB to prove that.
-    std::optional<ContractClass> get_contract_class(const ContractClassId& class_id) override;
+    std::optional<ContractClass> get_contract_class(const ContractClassId& class_id) const override;
 
   private:
     ContractDBInterface& raw_contract_db;

barretenberg/cpp/src/barretenberg/vm2/simulation/interfaces/db.hpp

@@ -18,8 +18,8 @@ class ContractDBInterface {
   public:
     virtual ~ContractDBInterface() = default;
 
-    virtual std::optional<ContractInstance> get_contract_instance(const AztecAddress& address) = 0;
-    virtual std::optional<ContractClass> get_contract_class(const ContractClassId& class_id) = 0;
+    virtual std::optional<ContractInstance> get_contract_instance(const AztecAddress& address) const = 0;
+    virtual std::optional<ContractClass> get_contract_class(const ContractClassId& class_id) const = 0;
 };
 
 // Aliases.
@@ -45,13 +45,13 @@ class LowLevelMerkleDBInterface {
 
     virtual TreeSnapshots get_tree_roots() const = 0;
 
-    virtual SiblingPath get_sibling_path(MerkleTreeId tree_id, index_t leaf_index) = 0;
-    virtual GetLowIndexedLeafResponse get_low_indexed_leaf(MerkleTreeId tree_id, const FF& value) = 0;
+    virtual SiblingPath get_sibling_path(MerkleTreeId tree_id, index_t leaf_index) const = 0;
+    virtual GetLowIndexedLeafResponse get_low_indexed_leaf(MerkleTreeId tree_id, const FF& value) const = 0;
     // Returns the value if it exists, 0 otherwise.
-    virtual FF get_leaf_value(MerkleTreeId tree_id, index_t leaf_index) = 0;
+    virtual FF get_leaf_value(MerkleTreeId tree_id, index_t leaf_index) const = 0;
     // We don't template the preimage methods because templated methods cannot be virtual.
-    virtual IndexedLeaf<PublicDataLeafValue> get_leaf_preimage_public_data_tree(index_t leaf_index) = 0;
-    virtual IndexedLeaf<NullifierLeafValue> get_leaf_preimage_nullifier_tree(index_t leaf_index) = 0;
+    virtual IndexedLeaf<PublicDataLeafValue> get_leaf_preimage_public_data_tree(index_t leaf_index) const = 0;
+    virtual IndexedLeaf<NullifierLeafValue> get_leaf_preimage_nullifier_tree(index_t leaf_index) const = 0;
 
     virtual SequentialInsertionResult<PublicDataLeafValue> insert_indexed_leaves_public_data_tree(
         const PublicDataLeafValue& leaf_value) = 0;

barretenberg/cpp/src/barretenberg/vm2/simulation/lib/db_types.hpp

@@ -3,12 +3,39 @@
 #include "barretenberg/crypto/merkle_tree/indexed_tree/indexed_leaf.hpp"
 #include "barretenberg/crypto/merkle_tree/types.hpp"
 #include "barretenberg/vm2/common/aztec_types.hpp"
+#include "barretenberg/vm2/common/map.hpp"
+#include "barretenberg/vm2/simulation/interfaces/db.hpp"
 
 namespace bb::avm2::simulation {
 
 using NullifierTreeLeafPreimage = crypto::merkle_tree::IndexedLeaf<crypto::merkle_tree::NullifierLeafValue>;
 using PublicDataTreeLeafPreimage = crypto::merkle_tree::IndexedLeaf<crypto::merkle_tree::PublicDataLeafValue>;
 
+// Keys for hints stored in unordered_flat_maps, used in raw_data_dbs and hinting_dbs.
+using GetSiblingPathKey = std::tuple<AppendOnlyTreeSnapshot, MerkleTreeId, index_t>;
+using GetPreviousValueIndexKey = std::tuple<AppendOnlyTreeSnapshot, MerkleTreeId, FF>;
+using GetLeafPreimageKey = std::tuple<AppendOnlyTreeSnapshot, index_t>;
+using GetLeafValueKey = std::tuple<AppendOnlyTreeSnapshot, MerkleTreeId, index_t>;
+using SequentialInsertHintPublicDataTreeKey = std::tuple<AppendOnlyTreeSnapshot, MerkleTreeId, PublicDataLeafValue>;
+using SequentialInsertHintNullifierTreeKey = std::tuple<AppendOnlyTreeSnapshot, MerkleTreeId, NullifierLeafValue>;
+using AppendLeavesHintKey = std::tuple<AppendOnlyTreeSnapshot, MerkleTreeId, std::vector<FF>>;
+
+// TODO(MW): Temp struct for query hints to allow using a ref in the HintingContractsDB class constructor
+struct MappedContractHints {
+    unordered_flat_map<AztecAddress, ContractInstanceHint> contract_instances;
+    unordered_flat_map<ContractClassId, ContractClassHint> contract_classes;
+    unordered_flat_map<ContractClassId, BytecodeCommitmentHint> bytecode_commitments;
+};
+
+// TODO(MW): Temp struct for query hints to allow using a ref in the HintingRawDB class constructor
+struct MappedQueryHints {
+    unordered_flat_map<GetSiblingPathKey, SiblingPath> get_sibling_path_hints;
+    unordered_flat_map<GetPreviousValueIndexKey, GetLowIndexedLeafResponse> get_previous_value_index_hints;
+    unordered_flat_map<GetLeafPreimageKey, IndexedLeaf<PublicDataLeafValue>> get_leaf_preimage_hints_public_data_tree;
+    unordered_flat_map<GetLeafPreimageKey, IndexedLeaf<NullifierLeafValue>> get_leaf_preimage_hints_nullifier_tree;
+    unordered_flat_map<GetLeafValueKey, FF> get_leaf_value_hints;
+};
+
 struct TreeCounters {
     uint32_t note_hash_counter;
     uint32_t nullifier_counter;

barretenberg/cpp/src/barretenberg/vm2/simulation/lib/hinting_dbs.cpp

@@ -1,6 +1,5 @@
 #include "barretenberg/vm2/simulation/lib/hinting_dbs.hpp"
 
-#include <cassert>
 #include <cstdint>
 #include <optional>
 #include <span>
@@ -10,10 +9,8 @@
 
 #include "barretenberg/common/bb_bench.hpp"
 #include "barretenberg/common/log.hpp"
-#include "barretenberg/crypto/merkle_tree/indexed_tree/indexed_leaf.hpp"
 #include "barretenberg/vm2/common/avm_inputs.hpp"
 #include "barretenberg/vm2/common/aztec_types.hpp"
-#include "barretenberg/vm2/generated/relations/lookups_contract_instance_retrieval.hpp"
 #include "barretenberg/vm2/simulation/interfaces/db.hpp"
 #include "barretenberg/vm2/simulation/lib/contract_crypto.hpp"
 
@@ -41,15 +38,15 @@ auto& get_tree_info_helper(world_state::MerkleTreeId tree_id, const auto& tree_r
 } // namespace
 
 // HintingContractsDB starts.
-std::optional<ContractInstance> HintingContractsDB::get_contract_instance(const AztecAddress& address)
+std::optional<ContractInstance> HintingContractsDB::get_contract_instance(const AztecAddress& address) const
 {
     info("HintingContractsDB get_contract_instance");
     auto instance = db.get_contract_instance(address);
     // If we don't find the instance hint, this is not a catastrophic failure. The inner db should handle it, and
     // here we simply don't store any hint:
     if (instance.has_value()) {
         // TODO(MW): Use/write instance to hint methods for ContractInstance, PublicKeys, ContractClass, etc.
-        contract_instances[address] = ContractInstanceHint{
+        mapped_hints.contract_instances[address] = ContractInstanceHint{
             .address = address,
             .salt = instance->salt,
             .deployer = instance->deployer_addr,
@@ -67,23 +64,23 @@ std::optional<ContractInstance> HintingContractsDB::get_contract_instance(const
     return instance;
 }
 
-std::optional<ContractClass> HintingContractsDB::get_contract_class(const ContractClassId& class_id)
+std::optional<ContractClass> HintingContractsDB::get_contract_class(const ContractClassId& class_id) const
 {
     info("HintingContractsDB get_contract_class");
     auto klass = db.get_contract_class(class_id);
     // If we don't find the instance hint, this is not a catastrophic failure. The inner db should handle it, and
     // here we simply don't store any hint:
     if (klass.has_value()) {
         // TODO(MW): Use/write instance to hint methods for ContractInstance, PublicKeys, ContractClass, etc.
-        contract_classes[class_id] = ContractClassHint{
+        mapped_hints.contract_classes[class_id] = ContractClassHint{
             .classId = class_id,
             .artifactHash = klass->artifact_hash,
             .privateFunctionsRoot = klass->private_function_root,
             .packedBytecode = klass->packed_bytecode,
         };
         // Note: HintedRawContractDB accesses the bytecode commitment 'hint' during get_contract_class, so following
         // same logic here:
-        bytecode_commitments[class_id] =
+        mapped_hints.bytecode_commitments[class_id] =
             BytecodeCommitmentHint{ .classId = class_id, .commitment = klass->public_bytecode_commitment };
     }
 
@@ -93,13 +90,13 @@ std::optional<ContractClass> HintingContractsDB::get_contract_class(const Contra
 void HintingContractsDB::dump_hints(ExecutionHints& hints)
 {
     // TODO(MW): better way than to iterate? do we want push_back?
-    for (const auto& contract_instance : contract_instances) {
+    for (const auto& contract_instance : mapped_hints.contract_instances) {
         hints.contractInstances.push_back(contract_instance.second);
     }
-    for (const auto& contract_class : contract_classes) {
+    for (const auto& contract_class : mapped_hints.contract_classes) {
         hints.contractClasses.push_back(contract_class.second);
     }
-    for (const auto& bytecode_commitment : bytecode_commitments) {
+    for (const auto& bytecode_commitment : mapped_hints.bytecode_commitments) {
         hints.bytecodeCommitments.push_back(bytecode_commitment.second);
     }
 }
@@ -110,61 +107,61 @@ const AppendOnlyTreeSnapshot& HintingRawDB::get_tree_info(world_state::MerkleTre
     return get_tree_info_helper(tree_id, db.get_tree_roots());
 }
 
-SiblingPath HintingRawDB::get_sibling_path(world_state::MerkleTreeId tree_id, index_t leaf_index)
+SiblingPath HintingRawDB::get_sibling_path(world_state::MerkleTreeId tree_id, index_t leaf_index) const
 {
     info("HintingRawDB get_sib: ", leaf_index);
     auto tree_info = get_tree_info(tree_id);
     auto path = db.get_sibling_path(tree_id, leaf_index);
     GetSiblingPathKey key = { tree_info, tree_id, leaf_index };
-    get_sibling_path_hints[key] = path;
+    query_hints.get_sibling_path_hints[key] = path;
 
     return path;
 }
 
-GetLowIndexedLeafResponse HintingRawDB::get_low_indexed_leaf(world_state::MerkleTreeId tree_id, const FF& value)
+GetLowIndexedLeafResponse HintingRawDB::get_low_indexed_leaf(world_state::MerkleTreeId tree_id, const FF& value) const
 {
     info("HintingRawDB get_low_indexed_leaf");
     auto tree_info = get_tree_info(tree_id);
     auto resp = db.get_low_indexed_leaf(tree_id, value);
     GetPreviousValueIndexKey key = { tree_info, tree_id, value };
-    get_previous_value_index_hints[key] = { resp.is_already_present, resp.index };
+    query_hints.get_previous_value_index_hints[key] = { resp.is_already_present, resp.index };
     // TODO(MW): We may need a sibling path hint so must collect it in case - see comments in public_db_sources.ts
     get_sibling_path(tree_id, resp.index);
     return resp;
 }
 
-FF HintingRawDB::get_leaf_value(world_state::MerkleTreeId tree_id, index_t leaf_index)
+FF HintingRawDB::get_leaf_value(world_state::MerkleTreeId tree_id, index_t leaf_index) const
 {
     info("HintingRawDB get_leaf_value");
     auto tree_info = get_tree_info(tree_id);
     auto value = db.get_leaf_value(tree_id, leaf_index);
     GetLeafValueKey key = { tree_info, tree_id, leaf_index };
-    get_leaf_value_hints[key] = value;
+    query_hints.get_leaf_value_hints[key] = value;
     // TODO(MW): We may need a sibling path hint so must collect it in case - see comments in public_db_sources.ts
     get_sibling_path(tree_id, leaf_index);
     return value;
 }
 
-IndexedLeaf<PublicDataLeafValue> HintingRawDB::get_leaf_preimage_public_data_tree(index_t leaf_index)
+IndexedLeaf<PublicDataLeafValue> HintingRawDB::get_leaf_preimage_public_data_tree(index_t leaf_index) const
 {
     info("HintingRawDB get_leaf_preimage_public_data_tree");
     auto tree_info = get_tree_info(world_state::MerkleTreeId::PUBLIC_DATA_TREE);
     auto preimage = db.get_leaf_preimage_public_data_tree(leaf_index);
 
     GetLeafPreimageKey key = { tree_info, leaf_index };
-    get_leaf_preimage_hints_public_data_tree[key] = preimage;
+    query_hints.get_leaf_preimage_hints_public_data_tree[key] = preimage;
     // TODO(MW): We may need a sibling path hint so must collect it in case - see comments in public_db_sources.ts
     get_sibling_path(world_state::MerkleTreeId::PUBLIC_DATA_TREE, leaf_index);
     return preimage;
 }
 
-IndexedLeaf<NullifierLeafValue> HintingRawDB::get_leaf_preimage_nullifier_tree(index_t leaf_index)
+IndexedLeaf<NullifierLeafValue> HintingRawDB::get_leaf_preimage_nullifier_tree(index_t leaf_index) const
 {
     info("HintingRawDB get_leaf_preimage_nullifier_tree");
     auto tree_info = get_tree_info(world_state::MerkleTreeId::NULLIFIER_TREE);
     auto preimage = db.get_leaf_preimage_nullifier_tree(leaf_index);
     GetLeafPreimageKey key = { tree_info, leaf_index };
-    get_leaf_preimage_hints_nullifier_tree[key] = preimage;
+    query_hints.get_leaf_preimage_hints_nullifier_tree[key] = preimage;
     // TODO(MW): We may need a sibling path hint so must collect it in case - see comments in public_db_sources.ts
     get_sibling_path(world_state::MerkleTreeId::NULLIFIER_TREE, leaf_index);
     return preimage;
@@ -320,12 +317,12 @@ AppendOnlyTreeSnapshot HintingRawDB::appendLeafInternal(AppendOnlyTreeSnapshot s
 void HintingRawDB::dump_hints(ExecutionHints& hints)
 {
     // TODO(MW): better way than to iterate? do we want push_back?
-    for (const auto& get_sibling_path_hint : get_sibling_path_hints) {
+    for (const auto& get_sibling_path_hint : query_hints.get_sibling_path_hints) {
         auto [hint_key, tree_id, index] = get_sibling_path_hint.first;
         hints.getSiblingPathHints.push_back(GetSiblingPathHint{
             .hintKey = hint_key, .treeId = tree_id, .index = index, .path = get_sibling_path_hint.second });
     }
-    for (const auto& get_previous_value_index_hint : get_previous_value_index_hints) {
+    for (const auto& get_previous_value_index_hint : query_hints.get_previous_value_index_hints) {
         auto [hint_key, tree_id, value] = get_previous_value_index_hint.first;
         hints.getPreviousValueIndexHints.push_back(GetPreviousValueIndexHint{
             .hintKey = hint_key,
@@ -335,17 +332,17 @@ void HintingRawDB::dump_hints(ExecutionHints& hints)
             .alreadyPresent = get_previous_value_index_hint.second.is_already_present,
         });
     }
-    for (const auto& get_leaf_preimage_hint : get_leaf_preimage_hints_public_data_tree) {
+    for (const auto& get_leaf_preimage_hint : query_hints.get_leaf_preimage_hints_public_data_tree) {
         auto [hint_key, index] = get_leaf_preimage_hint.first;
         hints.getLeafPreimageHintsPublicDataTree.push_back(
             { .hintKey = hint_key, .index = index, .leafPreimage = get_leaf_preimage_hint.second });
     }
-    for (const auto& get_leaf_preimage_hint : get_leaf_preimage_hints_nullifier_tree) {
+    for (const auto& get_leaf_preimage_hint : query_hints.get_leaf_preimage_hints_nullifier_tree) {
         auto [hint_key, index] = get_leaf_preimage_hint.first;
         hints.getLeafPreimageHintsNullifierTree.push_back(
             { .hintKey = hint_key, .index = index, .leafPreimage = get_leaf_preimage_hint.second });
     }
-    for (const auto& get_leaf_value_hint : get_leaf_value_hints) {
+    for (const auto& get_leaf_value_hint : query_hints.get_leaf_value_hints) {
         auto [hint_key, tree_id, index] = get_leaf_value_hint.first;
         hints.getLeafValueHints.push_back(GetLeafValueHint{
             .hintKey = hint_key, .treeId = tree_id, .index = index, .value = get_leaf_value_hint.second });