@@ -1,151 +0,0 @@
-use super::{
-    BTreeMap, KvMap, MerkleError, MerkleStore, NodeIndex, RpoDigest, StoreNode, Vec, Word,
-};
-use crate::utils::collections::Diff;
-
-#[cfg(test)]
-use super::{super::ONE, Felt, SimpleSmt, EMPTY_WORD, ZERO};
-
-// MERKLE STORE DELTA
-// ================================================================================================
-
-/// [MerkleStoreDelta] stores a vector of ([RpoDigest], [MerkleTreeDelta]) tuples where the
-/// [RpoDigest] represents the root of the Merkle tree and [MerkleTreeDelta] represents the
-/// differences between the initial and final Merkle tree states.
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub struct MerkleStoreDelta(pub Vec<(RpoDigest, MerkleTreeDelta)>);
-
-// MERKLE TREE DELTA
-// ================================================================================================
-
-/// [MerkleTreeDelta] stores the differences between the initial and final Merkle tree states.
-///
-/// The differences are represented as follows:
-/// - depth: the depth of the merkle tree.
-/// - cleared_slots: indexes of slots where values were set to [ZERO; 4].
-/// - updated_slots: index-value pairs of slots where values were set to non [ZERO; 4] values.
-#[derive(Debug, Clone, PartialEq, Eq)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub struct MerkleTreeDelta {
-    depth: u8,
-    cleared_slots: Vec<u64>,
-    updated_slots: Vec<(u64, Word)>,
-}
-
-impl MerkleTreeDelta {
-    // CONSTRUCTOR
-    // --------------------------------------------------------------------------------------------
-    pub fn new(depth: u8) -> Self {
-        Self {
-            depth,
-            cleared_slots: Vec::new(),
-            updated_slots: Vec::new(),
-        }
-    }
-
-    // ACCESSORS
-    // --------------------------------------------------------------------------------------------
-    /// Returns the depth of the Merkle tree the [MerkleTreeDelta] is associated with.
-    pub fn depth(&self) -> u8 {
-        self.depth
-    }
-
-    /// Returns the indexes of slots where values were set to [ZERO; 4].
-    pub fn cleared_slots(&self) -> &[u64] {
-        &self.cleared_slots
-    }
-
-    /// Returns the index-value pairs of slots where values were set to non [ZERO; 4] values.
-    pub fn updated_slots(&self) -> &[(u64, Word)] {
-        &self.updated_slots
-    }
-
-    // MODIFIERS
-    // --------------------------------------------------------------------------------------------
-    /// Adds a slot index to the list of cleared slots.
-    pub fn add_cleared_slot(&mut self, index: u64) {
-        self.cleared_slots.push(index);
-    }
-
-    /// Adds a slot index and a value to the list of updated slots.
-    pub fn add_updated_slot(&mut self, index: u64, value: Word) {
-        self.updated_slots.push((index, value));
-    }
-}
-
-/// Extracts a [MerkleTreeDelta] object by comparing the leaves of two Merkle trees specifies by
-/// their roots and depth.
-pub fn merkle_tree_delta<T: KvMap<RpoDigest, StoreNode>>(
-    tree_root_1: RpoDigest,
-    tree_root_2: RpoDigest,
-    depth: u8,
-    merkle_store: &MerkleStore<T>,
-) -> Result<MerkleTreeDelta, MerkleError> {
-    if tree_root_1 == tree_root_2 {
-        return Ok(MerkleTreeDelta::new(depth));
-    }
-
-    let tree_1_leaves: BTreeMap<NodeIndex, RpoDigest> =
-        merkle_store.non_empty_leaves(tree_root_1, depth).collect();
-    let tree_2_leaves: BTreeMap<NodeIndex, RpoDigest> =
-        merkle_store.non_empty_leaves(tree_root_2, depth).collect();
-    let diff = tree_1_leaves.diff(&tree_2_leaves);
-
-    // TODO: Refactor this diff implementation to prevent allocation of both BTree and Vec.
-    Ok(MerkleTreeDelta {
-        depth,
-        cleared_slots: diff.removed.into_iter().map(|index| index.value()).collect(),
-        updated_slots: diff
-            .updated
-            .into_iter()
-            .map(|(index, leaf)| (index.value(), *leaf))
-            .collect(),
-    })
-}
-
-// TESTS
-// ================================================================================================
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_compute_merkle_delta() {
-        const TREE_DEPTH: u8 = 30;
-
-        let entries = vec![
-            (10, [ZERO, ONE, Felt::new(2), Felt::new(3)]),
-            (15, [Felt::new(4), Felt::new(5), Felt::new(6), Felt::new(7)]),
-            (20, [Felt::new(8), Felt::new(9), Felt::new(10), Felt::new(11)]),
-            (31, [Felt::new(12), Felt::new(13), Felt::new(14), Felt::new(15)]),
-        ];
-        let simple_smt = SimpleSmt::<TREE_DEPTH>::with_leaves(entries.clone()).unwrap();
-        let mut store: MerkleStore = (&simple_smt).into();
-        let root = simple_smt.root();
-
-        // add a new node
-        let new_value = [Felt::new(16), Felt::new(17), Felt::new(18), Felt::new(19)];
-        let new_index = NodeIndex::new(TREE_DEPTH, 32).unwrap();
-        let root = store.set_node(root, new_index, new_value.into()).unwrap().root;
-
-        // update an existing node
-        let update_value = [Felt::new(20), Felt::new(21), Felt::new(22), Felt::new(23)];
-        let update_idx = NodeIndex::new(TREE_DEPTH, entries[0].0).unwrap();
-        let root = store.set_node(root, update_idx, update_value.into()).unwrap().root;
-
-        // remove a node
-        let remove_idx = NodeIndex::new(TREE_DEPTH, entries[1].0).unwrap();
-        let root = store.set_node(root, remove_idx, EMPTY_WORD.into()).unwrap().root;
-
-        let merkle_delta = merkle_tree_delta(simple_smt.root(), root, TREE_DEPTH, &store).unwrap();
-        let expected_merkle_delta = MerkleTreeDelta {
-            depth: TREE_DEPTH,
-            cleared_slots: vec![remove_idx.value()],
-            updated_slots: vec![(update_idx.value(), update_value), (new_index.value(), new_value)],
-        };
-
-        assert_eq!(merkle_delta, expected_merkle_delta);
-    }
-}

@@ -2,7 +2,7 @@ //! Data structures related to Merkle trees based on RPO256 hash function.
 
 use super::{
     hash::rpo::{Rpo256, RpoDigest},
-    utils::collections::{vec, BTreeMap, BTreeSet, KvMap, RecordingMap, TryApplyDiff, Vec},
+    utils::collections::{vec, BTreeMap, BTreeSet, KvMap, RecordingMap, Vec},
     Felt, StarkField, Word, EMPTY_WORD, ZERO,
 };
 
@@ -11,9 +11,6 @@ // ================================================================================================
 
 mod empty_roots;
 pub use empty_roots::EmptySubtreeRoots;
-
-mod delta;
-pub use delta::{merkle_tree_delta, MerkleStoreDelta, MerkleTreeDelta};
 
 mod index;
 pub use index::NodeIndex;

@@ -1,6 +1,5 @@
 use crate::{
-    merkle::{EmptySubtreeRoots, InnerNodeInfo, MerkleTreeDelta, StoreNode, ValuePath},
-    utils::collections::TryApplyDiff,
+    merkle::{EmptySubtreeRoots, InnerNodeInfo, ValuePath},
     EMPTY_WORD,
 };
 
@@ -300,26 +299,3 @@ fn key_to_leaf_index(key: &LeafIndex<DEPTH>) -> LeafIndex<DEPTH> {
         *key
     }
 }
-
-// TRY APPLY DIFF
-// ================================================================================================
-impl<const DEPTH: u8> TryApplyDiff<RpoDigest, StoreNode> for SimpleSmt<DEPTH> {
-    type Error = MerkleError;
-    type DiffType = MerkleTreeDelta;
-
-    fn try_apply(&mut self, diff: MerkleTreeDelta) -> Result<(), MerkleError> {
-        if diff.depth() != DEPTH {
-            return Err(MerkleError::InvalidDepth { expected: DEPTH, provided: diff.depth() });
-        }
-
-        for slot in diff.cleared_slots() {
-            self.insert(LeafIndex::<DEPTH>::new(*slot)?, Self::EMPTY_VALUE);
-        }
-
-        for (slot, value) in diff.updated_slots() {
-            self.insert(LeafIndex::<DEPTH>::new(*slot)?, *value);
-        }
-
-        Ok(())
-    }
-}

@@ -1,7 +1,7 @@
 use super::{
     mmr::Mmr, BTreeMap, EmptySubtreeRoots, InnerNodeInfo, KvMap, MerkleError, MerklePath,
-    MerkleStoreDelta, MerkleTree, NodeIndex, PartialMerkleTree, RecordingMap, RootPath, Rpo256,
-    RpoDigest, SimpleSmt, TieredSmt, TryApplyDiff, ValuePath, Vec, EMPTY_WORD,
+    MerkleTree, NodeIndex, PartialMerkleTree, RecordingMap, RootPath, Rpo256, RpoDigest, SimpleSmt,
+    TieredSmt, ValuePath, Vec,
 };
 use crate::utils::{ByteReader, ByteWriter, Deserializable, DeserializationError, Serializable};
 use core::borrow::Borrow;
@@ -547,39 +547,6 @@ self.nodes.extend(
             iter.into_iter()
                 .map(|info| (info.value, StoreNode { left: info.left, right: info.right })),
         );
-    }
-}
-
-// DiffT & ApplyDiffT TRAIT IMPLEMENTATION
-// ================================================================================================
-impl<T: KvMap<RpoDigest, StoreNode>> TryApplyDiff<RpoDigest, StoreNode> for MerkleStore<T> {
-    type Error = MerkleError;
-    type DiffType = MerkleStoreDelta;
-
-    fn try_apply(&mut self, diff: Self::DiffType) -> Result<(), MerkleError> {
-        for (root, delta) in diff.0 {
-            let mut root = root;
-            for cleared_slot in delta.cleared_slots() {
-                root = self
-                    .set_node(
-                        root,
-                        NodeIndex::new(delta.depth(), *cleared_slot)?,
-                        EMPTY_WORD.into(),
-                    )?
-                    .root;
-            }
-            for (updated_slot, updated_value) in delta.updated_slots() {
-                root = self
-                    .set_node(
-                        root,
-                        NodeIndex::new(delta.depth(), *updated_slot)?,
-                        (*updated_value).into(),
-                    )?
-                    .root;
-            }
-        }
-
-        Ok(())
     }
 }
 

@@ -1,31 +0,0 @@
-/// A trait for computing the difference between two objects.
-pub trait Diff<K: Ord + Clone, V: Clone> {
-    /// The type that describes the difference between two objects.
-    type DiffType;
-
-    /// Returns a [Self::DiffType] object that represents the difference between this object and
-    /// other.
-    fn diff(&self, other: &Self) -> Self::DiffType;
-}
-
-/// A trait for applying the difference between two objects.
-pub trait ApplyDiff<K: Ord + Clone, V: Clone> {
-    /// The type that describes the difference between two objects.
-    type DiffType;
-
-    /// Applies the provided changes described by [Self::DiffType] to the object implementing this trait.
-    fn apply(&mut self, diff: Self::DiffType);
-}
-
-/// A trait for applying the difference between two objects with the possibility of failure.
-pub trait TryApplyDiff<K: Ord + Clone, V: Clone> {
-    /// The type that describes the difference between two objects.
-    type DiffType;
-
-    /// An error type that can be returned if the changes cannot be applied.
-    type Error;
-
-    /// Applies the provided changes described by [Self::DiffType] to the object implementing this trait.
-    /// Returns an error if the changes cannot be applied.
-    fn try_apply(&mut self, diff: Self::DiffType) -> Result<(), Self::Error>;
-}

@@ -1,4 +1,3 @@
-use super::{collections::ApplyDiff, diff::Diff};
 use core::cell::RefCell;
 use winter_utils::{
     collections::{btree_map::IntoIter, BTreeMap, BTreeSet},
@@ -209,74 +208,6 @@ self.data.into_iter()
     }
 }
 
-// KV MAP DIFF
-// ================================================================================================
-/// [KvMapDiff] stores the difference between two key-value maps.
-///
-/// The [KvMapDiff] is composed of two parts:
-/// - `updates` - a map of key-value pairs that were updated in the second map compared to the
-///               first map. This includes new key-value pairs.
-/// - `removed` - a set of keys that were removed from the second map compared to the first map.
-#[derive(Debug, Clone)]
-pub struct KvMapDiff<K, V> {
-    pub updated: BTreeMap<K, V>,
-    pub removed: BTreeSet<K>,
-}
-
-impl<K, V> KvMapDiff<K, V> {
-    // CONSTRUCTOR
-    // --------------------------------------------------------------------------------------------
-    /// Creates a new [KvMapDiff] instance.
-    pub fn new() -> Self {
-        KvMapDiff {
-            updated: BTreeMap::new(),
-            removed: BTreeSet::new(),
-        }
-    }
-}
-
-impl<K, V> Default for KvMapDiff<K, V> {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl<K: Ord + Clone, V: Clone + PartialEq, T: KvMap<K, V>> Diff<K, V> for T {
-    type DiffType = KvMapDiff<K, V>;
-
-    fn diff(&self, other: &T) -> Self::DiffType {
-        let mut diff = KvMapDiff::default();
-        for (k, v) in self.iter() {
-            if let Some(other_value) = other.get(k) {
-                if v != other_value {
-                    diff.updated.insert(k.clone(), other_value.clone());
-                }
-            } else {
-                diff.removed.insert(k.clone());
-            }
-        }
-        for (k, v) in other.iter() {
-            if self.get(k).is_none() {
-                diff.updated.insert(k.clone(), v.clone());
-            }
-        }
-        diff
-    }
-}
-
-impl<K: Ord + Clone, V: Clone, T: KvMap<K, V>> ApplyDiff<K, V> for T {
-    type DiffType = KvMapDiff<K, V>;
-
-    fn apply(&mut self, diff: Self::DiffType) {
-        for (k, v) in diff.updated {
-            self.insert(k, v);
-        }
-        for k in diff.removed {
-            self.remove(&k);
-        }
-    }
-}
-
 // TESTS
 // ================================================================================================
 
@@ -469,36 +400,5 @@ 0 => assert_eq!(proof.get(key), Some(value)),
                 _ => assert_eq!(proof.get(key), None),
             }
         }
-    }
-
-    #[test]
-    fn test_kv_map_diff() {
-        let mut initial_state = ITEMS.into_iter().collect::<BTreeMap<_, _>>();
-        let mut map = RecordingMap::new(initial_state.clone());
-
-        // remove an item that exists
-        let key = 0;
-        let _value = map.remove(&key).unwrap();
-
-        // add a new item
-        let key = 100;
-        let value = 100;
-        map.insert(key, value);
-
-        // update an existing item
-        let key = 1;
-        let value = 100;
-        map.insert(key, value);
-
-        // compute a diff
-        let diff = initial_state.diff(map.inner());
-        assert!(diff.updated.len() == 2);
-        assert!(diff.updated.iter().all(|(k, v)| [(100, 100), (1, 100)].contains(&(*k, *v))));
-        assert!(diff.removed.len() == 1);
-        assert!(diff.removed.first() == Some(&0));
-
-        // apply the diff to the initial state and assert the contents are the same as the map
-        initial_state.apply(diff);
-        assert!(initial_state.iter().eq(map.iter()));
     }
 }

@@ -9,7 +9,6 @@
 #[cfg(feature = "std")]
 pub use std::{format, vec};
 
-mod diff;
 mod kv_map;
 
 // RE-EXPORTS
@@ -20,7 +19,6 @@ Serializable, SliceReader,
 };
 
 pub mod collections {
-    pub use super::diff::*;
     pub use super::kv_map::*;
     pub use winter_utils::collections::*;
 }