initial commit: merkle exploration

<!-- ps-id: 682cbe9d-d3af-46de-89ed-ba202457fa74 -->

Author: nfurfaro

Cargo.lock

@@ -9,13 +9,15 @@ license.workspace = true
 repository.workspace = true
 
 [dependencies]
+blake2b-rs = "0.2.0"
 essential-check = { workspace = true }
 essential-hash = { workspace = true }
 essential-node-db = { workspace = true }
 essential-node-types = { workspace = true }
 essential-relayer = { workspace = true }
 essential-types = { workspace = true }
 futures = { workspace = true }
+sparse-merkle-tree = "0.6.1"
 rusqlite = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true }

crates/node/Cargo.toml

@@ -20,6 +20,7 @@ use validation::validation_stream;
 
 mod error;
 mod handles;
+mod merkle;
 #[cfg(any(feature = "test-utils", test))]
 #[allow(missing_docs)]
 pub mod test_utils;

crates/node/src/lib.rs

@@ -0,0 +1,55 @@
+use blake2b_rs::{Blake2b, Blake2bBuilder};
+use essential_types::{solution::Mutation, ContentAddress, Key, SolutionSet, Value, Word};
+use sparse_merkle_tree::{
+    blake2b::Blake2bHasher, default_store::DefaultStore, SparseMerkleTree, H256,
+};
+use std::collections::HashMap;
+
+#[cfg(test)]
+mod tests;
+
+// TODO: chose between HashMap & BTreeMap. Is State already defined?
+#[derive(Clone, Debug)]
+pub struct State(HashMap<ContentAddress, HashMap<Key, Vec<Word>>>);
+
+// define SMT
+type SMT = SparseMerkleTree<Blake2bHasher, Word, DefaultStore<Word>>;
+
+impl State {
+    // Empry state, fine for tests unrelated to reading state.
+    pub fn empty() -> Self {
+        State(HashMap::new())
+    }
+}
+
+impl PartialEq for State {
+    fn eq(&self, other: &Self) -> bool {
+        self.0 == other.0
+    }
+}
+
+// Expose a function that takes a solution set and a State, and applies it to the state.
+pub fn apply_solution_set(set: &SolutionSet, state: &mut State) -> State {
+    for solution in set.solutions.iter() {
+        let contract_address = &solution.predicate_to_solve.contract;
+
+        // Get or create the inner HashMap for the contract address
+        let inner_map = state
+            .0
+            .entry(contract_address.clone())
+            .or_insert_with(HashMap::new);
+
+        // Borrow `state_mutations` to avoid moving it
+        for mutation in &solution.state_mutations {
+            inner_map.insert(mutation.key.clone(), mutation.value.clone());
+        }
+    }
+    state.clone()
+}
+
+// Expose a function which takes a State and returns a merkle tree
+fn generate_merkle_tree(state: &State) -> SMT {
+    // TODO: chose hashing algorithm to use.
+    // TODO: look into how we generate a MerkleTree from a hashmap.
+    SMT::default()
+}

crates/node/src/merkle.rs

@@ -0,0 +1,70 @@
+use super::*;
+use essential_types::{
+    solution::Mutation, ContentAddress, PredicateAddress, Solution, SolutionSet, Word,
+};
+use sparse_merkle_tree::{
+    blake2b::Blake2bHasher, default_store::DefaultStore, SparseMerkleTree, H256,
+};
+
+fn test_mutation(salt: usize, val: Word) -> Mutation {
+    Mutation {
+        key: vec![salt as Word; 4],
+        value: vec![val],
+    }
+}
+
+#[test]
+fn test_apply_solution_set() {
+    let solution = Solution {
+        predicate_to_solve: PredicateAddress {
+            contract: ContentAddress([0u8; 32]),
+            predicate: ContentAddress([0u8; 32]),
+        },
+        predicate_data: vec![],
+        state_mutations: vec![test_mutation(0, 42)],
+    };
+    let solution_set = SolutionSet {
+        solutions: vec![solution.clone()],
+    };
+    let mut state = State::empty();
+
+    let mut expected_state = state.clone();
+    let inner_map = expected_state
+        .0
+        .entry(solution.predicate_to_solve.contract)
+        .or_insert(HashMap::new());
+
+    inner_map.insert(
+        solution.state_mutations[0].key.clone(),
+        solution.state_mutations[0].value.clone(),
+    );
+
+    let updated_state = apply_solution_set(&solution_set, &mut state);
+
+    assert_eq!(updated_state, expected_state);
+}
+
+#[test]
+fn test_generate_merkle_tree() {
+    // Create a mock state (key-value pairs)
+    let key1 = H256::from([0u8; 32]);
+    let value = H256::from([1u8; 32]);
+    let key2 = H256::from([2u8; 32]);
+    let value2 = H256::from([3u8; 32]);
+    let state = State::empty();
+
+    let mut smt = SMT::default();
+
+    // Insert key-value pairs into the tree
+    // smt.update(key1, value1).unwrap();
+    // smt.update(key2, value2).unwrap();
+
+    // Generate the expected root hash manually
+    let expected_root = smt.root();
+
+    // Call your function to generate the Merkle tree
+    let generated_merkle_tree = generate_merkle_tree(&state);
+
+    // Assert that the generated Merkle tree's root matches the expected root
+    assert_eq!(generated_merkle_tree.root(), expected_root);
+}