Add Keccak-based Merkle Tree implementation and tests

- Implemented Keccak-based hashing functions and Merkle Tree construction.
- Added examples of creating and verifying Merkle Trees using both SHA-256 and Keccak hashing.
- Created a new module `merkle.rs` for an alternative Merkle Tree implementation using the `ring` crate.
- Added test cases to verify the functionality of both Merkle Tree implementations.

Author: devgreek

Cargo.lock

@@ -1,7 +1,10 @@
 [package]
-name = "merkle-treee-rs"
+name = "merkle-tree-rs"
 version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-sha2 = "0.9"
+sha2 = "0.9"
+tiny-keccak = { version = "2.0", features = ["keccak"] }
+hex = "0.4"
+ring = "0.16.20"

Cargo.toml

@@ -0,0 +1,60 @@
+use ring::digest::{Context, SHA256};
+
+#[derive(Debug)]
+enum Node {
+    Leaf(Vec<u8>), // Data
+    Internal(Box<Node>, Box<Node>), // Left, Right children
+}
+
+fn calculate_hash(data: &[u8]) -> Vec<u8> {
+    let mut context = Context::new(&SHA256);
+    context.update(data);
+    let digest = context.finish();
+    digest.as_ref().to_vec()
+}
+
+impl Node {
+    fn new_leaf(data: Vec<u8>) -> Self {
+        Node::Leaf(data)
+    }
+
+    fn new_internal(left: Node, right: Node) -> Self {
+        Node::Internal(Box::new(left), Box::new(right))
+    }
+
+    fn compute_hash(&self) -> Vec<u8> {
+        match self {
+            Node::Leaf(data) => calculate_hash(data),
+            Node::Internal(left, right) => {
+                let left_hash = left.compute_hash();
+                let right_hash = right.compute_hash();
+                let combined = [&left_hash[..], &right_hash[..]].concat();
+                calculate_hash(&combined)
+            }
+        }
+    }
+}
+
+fn main() {
+    let data1 = b"Data Block 1".to_vec();
+    let data2 = b"Data Block 2".to_vec();
+    let data3 = b"Data Block 3".to_vec();
+
+    let leaf1 = Node::new_leaf(data1);
+    let leaf2 = Node::new_leaf(data2);
+    let leaf3 = Node::new_leaf(data3);
+
+    let internal1 = Node::new_internal(leaf1, leaf2);
+    let root = Node::new_internal(internal1, leaf3); // Unbalanced tree
+
+    let merkle_root = root.compute_hash();
+    println!("Merkle Root: {:?}", merkle_root);
+
+
+    // Example of adding a new leaf (making it more unbalanced):
+    let data4 = b"Data Block 4".to_vec();
+    let leaf4 = Node::new_leaf(data4);
+    let new_root = Node::new_internal(root, leaf4);
+    let new_merkle_root = new_root.compute_hash();
+    println!("New Merkle Root (after adding data): {:?}", new_merkle_root);
+}