merkle tree structure needed for FRI

cryptography/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "cryptography"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+rs_merkle = "1.4.1"
+ark-poly = "0.4.2"
+ark-ff = "0.4.2"
+ark-test-curves = "0.4.2"
+sha2 = "0.10.8"
+rand = { version = "0.8", features = [ "std", "std_rng" ] }
+sha3 = "0.10"
+thiserror = "1.0.38"
+serde = { version = "1.0", features = ["derive"] }
+rayon = { version = "1.8.0", optional = true }

cryptography/src/lib.rs

@@ -0,0 +1 @@
+pub mod merkle;

cryptography/src/merkle/common_utils.rs

@@ -0,0 +1,32 @@
+
+use super::tree::checkForValidMerkleTree;
+
+pub fn parent_idx (node_idx: usize) -> usize {
+    if node_idx % 2 == 0{
+        (node_idx - 1) / 2
+    }
+    else {
+        node_idx / 2
+    }
+}
+
+pub fn sibling_idx (node_idx: usize) -> usize {
+    if node_idx % 2 == 0 {
+        node_idx - 1
+    }
+    else {
+        node_idx + 1
+    }
+}
+
+pub fn fill_untill_pow_two <T:Clone>(values: &mut Vec<T>) -> Vec<T> {
+    while !is_power_of_two(values.len()){
+        values.push(values[values.len() - 1].clone())
+    }
+
+    values.to_vec() 
+}
+
+pub fn is_power_of_two(x: usize) -> bool {
+     (x != 0) && ((x & (x-1)) == 0) 
+}

cryptography/src/merkle/hash.rs

@@ -0,0 +1,42 @@
+use std::{marker::PhantomData, fmt::Debug};
+
+use ark_ff::PrimeField;
+use rs_merkle::{algorithms::Sha256, Hasher};
+
+pub trait Hash<F: PrimeField> {
+    type HashedVal: Clone + PartialEq + Debug + Copy;
+    fn hash_value(data: F) -> Self::HashedVal;
+    fn hash_left_right_child(lchild: Self::HashedVal, rchild: Self::HashedVal) -> Self::HashedVal;
+}
+
+#[derive(Clone, Debug)]
+pub struct Sha256_ <F: PrimeField> {
+    _marker: PhantomData<F>,
+}
+
+pub fn usize_slice_to_u8_slice(usizes: &[usize]) -> Vec<u8> {
+    let mut bytes = Vec::new();
+    for &usize_val in usizes {
+        let usize_bytes = usize_val.to_le_bytes();
+        bytes.extend_from_slice(&usize_bytes);
+    }
+    bytes
+}
+
+impl <F: PrimeField> Hash<F> for Sha256_<F>{
+    type HashedVal = F;
+
+    fn hash_value(data: F) -> Self::HashedVal {
+        let vals: Vec<usize> = data.to_string().into() as Vec<usize>;
+        F::from_le_bytes_mod_order(&Sha256::hash(usize_slice_to_u8_slice(&vals)))
+    }
+
+    fn hash_left_right_child(lchild: Self::HashedVal, rchild: Self::HashedVal) -> Self::HashedVal {
+        let mut d_left : Vec<usize> = lchild.to_string().into() as Vec<usize>;
+        let mut d_right: Vec<usize> = rchild.to_string().into() as Vec<usize>;
+
+        d_left.append(&mut d_right);
+        let hashed_children: [u8; 32] = Sha256::hash(&d_left);
+        F::from_le_bytes_mod_order(&hashed_children)
+    }
+}

cryptography/src/merkle/mod.rs

@@ -0,0 +1,3 @@
+pub mod common_utils;
+pub mod tree;
+pub mod hash;

cryptography/src/merkle/tree.rs

@@ -0,0 +1,16 @@
+use ark_ff::PrimeField;
+use super::hash::Hash;
+
+
+//One stop checking trait that would import the tree content of a Valid Merkle Tree
+pub trait checkForValidMerkleTree: Default {
+    type Node: PartialEq + Eq + Clone + Sync + Send;
+    type Value: Sync + Send;
+
+    fn convert_to_node(leaf: &Self::Value) -> Self::Node;
+
+    fn hash_leaves(unhashed_leaves: &[Self::Value]) -> Vec<Self::Node> {
+
+    }
+
+}