[CLAUDE-GENERATED] feat(avm): fast simulation optimizations

Author: dbanks12

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

@@ -67,11 +67,41 @@ class LowLevelMerkleDBInterface {
     virtual SequentialInsertionResult<NullifierLeafValue> insert_indexed_leaves_nullifier_tree(
         const NullifierLeafValue& leaf_value) = 0;
 
+    // Batch insert methods for indexed trees. These provide true batch insertion when
+    // supported by the underlying implementation (e.g., WorldState).
+    // Default implementations loop over single inserts for backwards compatibility.
+    virtual void batch_insert_indexed_leaves_nullifier_tree(const std::vector<NullifierLeafValue>& leaves)
+    {
+        for (const auto& leaf : leaves) {
+            insert_indexed_leaves_nullifier_tree(leaf);
+        }
+    }
+    virtual void batch_insert_indexed_leaves_public_data_tree(const std::vector<PublicDataLeafValue>& leaves)
+    {
+        for (const auto& leaf : leaves) {
+            insert_indexed_leaves_public_data_tree(leaf);
+        }
+    }
+
     // todo(ilyas): does this need to be a vector of appendLeafResult? We should only care abou the end of appendings
     virtual std::vector<AppendLeafResult> append_leaves(MerkleTreeId tree_id, std::span<const FF> leaves) = 0;
 
     virtual void pad_tree(MerkleTreeId tree_id, size_t num_leaves) = 0;
 
+    // Combined flush + pad methods: insert data AND padding in a single underlying tree write.
+    // These avoid the overhead of separate insert and pad operations.
+    // Default implementations do separate operations for backwards compatibility.
+    virtual void flush_and_pad_nullifier_tree(const std::vector<NullifierLeafValue>& leaves, size_t padding_count)
+    {
+        batch_insert_indexed_leaves_nullifier_tree(leaves);
+        pad_tree(MerkleTreeId::NULLIFIER_TREE, padding_count);
+    }
+    virtual void flush_and_pad_note_hash_tree(const std::vector<FF>& leaves, size_t padding_count)
+    {
+        append_leaves(MerkleTreeId::NOTE_HASH_TREE, leaves);
+        pad_tree(MerkleTreeId::NOTE_HASH_TREE, padding_count);
+    }
+
     virtual void create_checkpoint() = 0;
     virtual void commit_checkpoint() = 0;
     virtual void revert_checkpoint() = 0;

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

@@ -776,6 +776,23 @@ SequentialInsertionResult<NullifierLeafValue> PureRawMerkleDB::insert_indexed_le
     return result;
 }
 
+void PureRawMerkleDB::batch_insert_indexed_leaves_nullifier_tree(const std::vector<NullifierLeafValue>& leaves)
+{
+    if (!leaves.empty()) {
+        // Use WorldState's true batch insert - this is much faster than inserting one by one.
+        ws_instance.insert_indexed_leaves<NullifierLeafValue>(MerkleTreeId::NULLIFIER_TREE, leaves, ws_revision.forkId);
+    }
+}
+
+void PureRawMerkleDB::batch_insert_indexed_leaves_public_data_tree(const std::vector<PublicDataLeafValue>& leaves)
+{
+    if (!leaves.empty()) {
+        // Use WorldState's true batch insert - this is much faster than inserting one by one.
+        ws_instance.insert_indexed_leaves<PublicDataLeafValue>(
+            MerkleTreeId::PUBLIC_DATA_TREE, leaves, ws_revision.forkId);
+    }
+}
+
 // This method currently returns a vector of intermediate roots and sibling paths, but in practice we might only
 // need or care about the last one for simulation, this would simplify how we append in this function.
 // todo(ilyas): Given this function says append, perhaps we just want to restrict to NoteHash?
@@ -811,6 +828,33 @@ void PureRawMerkleDB::pad_tree(MerkleTreeId tree_id, size_t num_leaves)
     }
 }
 
+void PureRawMerkleDB::flush_and_pad_nullifier_tree(const std::vector<NullifierLeafValue>& leaves, size_t padding_count)
+{
+    // Combine data and padding into a single batch insert.
+    std::vector<NullifierLeafValue> combined;
+    combined.reserve(leaves.size() + padding_count);
+    combined.insert(combined.end(), leaves.begin(), leaves.end());
+    combined.insert(combined.end(), padding_count, NullifierLeafValue::empty());
+
+    if (!combined.empty()) {
+        ws_instance.batch_insert_indexed_leaves(
+            MerkleTreeId::NULLIFIER_TREE, combined, NULLIFIER_SUBTREE_HEIGHT, ws_revision.forkId);
+    }
+}
+
+void PureRawMerkleDB::flush_and_pad_note_hash_tree(const std::vector<FF>& leaves, size_t padding_count)
+{
+    // Combine data and padding into a single append_leaves call.
+    std::vector<FF> combined;
+    combined.reserve(leaves.size() + padding_count);
+    combined.insert(combined.end(), leaves.begin(), leaves.end());
+    combined.insert(combined.end(), padding_count, FF(0));
+
+    if (!combined.empty()) {
+        ws_instance.append_leaves(MerkleTreeId::NOTE_HASH_TREE, combined, ws_revision.forkId);
+    }
+}
+
 void PureRawMerkleDB::create_checkpoint()
 {
     ws_instance.checkpoint(ws_revision.forkId);

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

@@ -133,8 +133,14 @@ class PureRawMerkleDB final : public LowLevelMerkleDBInterface {
         const PublicDataLeafValue& leaf_value) override;
     SequentialInsertionResult<NullifierLeafValue> insert_indexed_leaves_nullifier_tree(
         const NullifierLeafValue& leaf_value) override;
+    // True batch insert methods that use WorldState's batch APIs.
+    void batch_insert_indexed_leaves_nullifier_tree(const std::vector<NullifierLeafValue>& leaves) override;
+    void batch_insert_indexed_leaves_public_data_tree(const std::vector<PublicDataLeafValue>& leaves) override;
     std::vector<AppendLeafResult> append_leaves(MerkleTreeId tree_id, std::span<const FF> leaves) override;
     void pad_tree(MerkleTreeId tree_id, size_t num_leaves) override;
+    // Combined flush + pad methods for single tree write.
+    void flush_and_pad_nullifier_tree(const std::vector<NullifierLeafValue>& leaves, size_t padding_count) override;
+    void flush_and_pad_note_hash_tree(const std::vector<FF>& leaves, size_t padding_count) override;
 
     void create_checkpoint() override;
     void commit_checkpoint() override;