Merge pull request #54 from HerodotusDev/fix/accumulators-problems

Fix/accumulators problems

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "accumulators"
-version = "0.4.1"
+version = "0.4.2"
 edition = "2021"
 license-file = "LICENSE"
 description = "Complete package of multiple Accumulators with Stores and hashing functions (Hashers)"

benches/incremental_benchmark.rs

@@ -10,7 +10,9 @@ use tokio::runtime::Runtime;
 async fn prepare_incremental(count: usize) -> IncrementalMerkleTree<StarkPoseidonHasher> {
     let hasher = StarkPoseidonHasher::new(Some(false));
 
-    let store = SQLiteStore::new(":memory:", None).await.unwrap();
+    let store = SQLiteStore::new(":memory:", None, Some("test"))
+        .await
+        .unwrap();
 
     let store = Arc::new(store);
 

benches/mmr_benchmark.rs

@@ -9,7 +9,9 @@ use tokio::runtime::Runtime;
 async fn prepare_mmr(count: usize) -> MMR {
     let hasher = Arc::new(StarkPoseidonHasher::new(Some(false)));
 
-    let store = SQLiteStore::new(":memory:", None).await.unwrap();
+    let store = SQLiteStore::new(":memory:", None, Some("test"))
+        .await
+        .unwrap();
 
     let store = Arc::new(store);
 

src/mmr/mmrs/stacked.rs

@@ -16,12 +16,14 @@ impl MMR {
         store: Arc<dyn Store>,
         hasher: Arc<dyn Hasher>,
         mmr_id: Option<String>,
+        //? The sizes of the sub MMRs should be the stacks at size, not the actual current size
         sub_mmrs_metadata: SizesToMMRs,
     ) -> Result<Self, MMRError> {
         let mut mmr = MMR::new(store, hasher, mmr_id);
         let sub_mmrs_count = sub_mmrs_metadata.len();
         let mut sub_mmrs: Vec<SubMMR> = Vec::with_capacity(sub_mmrs_count);
 
+        //? size here should be stacks at size
         for (idx, (size, mmr_metadata)) in sub_mmrs_metadata.iter().enumerate() {
             let (_, _, _, hashes_table) =
                 MMR::get_stores(&mmr_metadata.mmr_id, mmr_metadata.store.clone());

src/store/core.rs

@@ -29,6 +29,8 @@ pub enum StoreError {
 /// Define common behavior for all stores
 #[async_trait]
 pub trait Store: Send + Sync + Debug {
+    /// Helper function to get the store identifier - useful for debugging
+    fn id(&self) -> String;
     /// Get a value from the store
     async fn get(&self, key: &str) -> Result<Option<String>, StoreError>;
 

src/store/stores/memory.rs

@@ -7,19 +7,25 @@ use crate::store::{Store, StoreError};
 /// A store that is stored in memory
 #[derive(Debug)]
 pub struct InMemoryStore {
+    pub id: Option<String>,
     pub store: RwLock<HashMap<String, String>>,
 }
 
 impl Default for InMemoryStore {
     fn default() -> Self {
         Self {
+            id: None,
             store: RwLock::new(HashMap::new()),
         }
     }
 }
 
 #[async_trait]
 impl Store for InMemoryStore {
+    fn id(&self) -> String {
+        self.id.clone().unwrap_or_default()
+    }
+
     async fn get(&self, key: &str) -> Result<Option<String>, StoreError> {
         let store = self.store.read();
         Ok(store.get(key).cloned())
@@ -64,8 +70,11 @@ impl Store for InMemoryStore {
 }
 
 impl InMemoryStore {
-    pub fn new() -> Self {
-        Self::default()
+    pub fn new(id: Option<&str>) -> Self {
+        Self {
+            id: id.map(|v| v.to_string()),
+            ..Default::default()
+        }
     }
 
     pub fn clear(&self) {

src/store/stores/sqlite.rs

@@ -11,11 +11,16 @@ use super::super::Store;
 /// A store that is stored in SQLite
 #[derive(Debug)]
 pub struct SQLiteStore {
+    pub id: Option<String>,
     db: Mutex<Pool<Sqlite>>,
 }
 
 impl SQLiteStore {
-    pub async fn new(path: &str, create_file_if_not_exists: Option<bool>) -> Result<Self, Error> {
+    pub async fn new(
+        path: &str,
+        create_file_if_not_exists: Option<bool>,
+        id: Option<&str>,
+    ) -> Result<Self, Error> {
         let pool = if let Some(create_file_if_not_exists) = create_file_if_not_exists {
             let options = SqliteConnectOptions::new()
                 .filename(path)
@@ -26,6 +31,7 @@ impl SQLiteStore {
         };
 
         let store = SQLiteStore {
+            id: id.map(|v| v.to_string()),
             db: Mutex::new(pool),
         };
         store.init().await?;
@@ -48,6 +54,10 @@ impl SQLiteStore {
 
 #[async_trait]
 impl Store for SQLiteStore {
+    fn id(&self) -> String {
+        self.id.clone().unwrap_or_default()
+    }
+
     async fn get(&self, key: &str) -> Result<Option<String>, StoreError> {
         let pool = self.db.lock().await;
 

tests/merkle_tree/incremental.rs

@@ -10,7 +10,9 @@ mod tests {
 
     #[tokio::test]
     async fn initialize() {
-        let store = SQLiteStore::new(":memory:", None).await.unwrap();
+        let store = SQLiteStore::new(":memory:", None, Some("test"))
+            .await
+            .unwrap();
         let hasher = StarkPoseidonHasher::new(Some(false));
 
         let store = Arc::new(store);
@@ -26,7 +28,9 @@ mod tests {
 
     #[tokio::test]
     async fn get_path() {
-        let store = SQLiteStore::new(":memory:", None).await.unwrap();
+        let store = SQLiteStore::new(":memory:", None, Some("test"))
+            .await
+            .unwrap();
         let hasher = StarkPoseidonHasher::new(Some(false));
 
         let store = Arc::new(store);
@@ -56,7 +60,9 @@ mod tests {
 
     #[tokio::test]
     async fn verify_proof() {
-        let store = SQLiteStore::new(":memory:", None).await.unwrap();
+        let store = SQLiteStore::new(":memory:", None, Some("test"))
+            .await
+            .unwrap();
         let hasher = StarkPoseidonHasher::new(Some(false));
 
         let store = Arc::new(store);
@@ -74,7 +80,9 @@ mod tests {
 
     #[tokio::test]
     async fn update() {
-        let store = SQLiteStore::new(":memory:", None).await.unwrap();
+        let store = SQLiteStore::new(":memory:", None, Some("test"))
+            .await
+            .unwrap();
         let hasher = StarkPoseidonHasher::new(Some(false));
 
         let store = Arc::new(store);
@@ -104,7 +112,9 @@ mod tests {
 
     #[tokio::test]
     async fn invalid_update() {
-        let store = SQLiteStore::new(":memory:", None).await.unwrap();
+        let store = SQLiteStore::new(":memory:", None, Some("test"))
+            .await
+            .unwrap();
         let hasher = StarkPoseidonHasher::new(Some(false));
 
         let store = Arc::new(store);
@@ -122,7 +132,9 @@ mod tests {
 
     #[tokio::test]
     async fn generate_and_verify_multi_proof() {
-        let store = SQLiteStore::new(":memory:", None).await.unwrap();
+        let store = SQLiteStore::new(":memory:", None, Some("test"))
+            .await
+            .unwrap();
         let hasher = StarkPoseidonHasher::new(Some(false));
 
         let store = Arc::new(store);
@@ -182,7 +194,7 @@ mod tests {
             merkle_tree::incremental::IncrementalMerkleTree, store::memory::InMemoryStore,
         };
 
-        let store = InMemoryStore::new();
+        let store = InMemoryStore::new(Some("test"));
         let store = Arc::new(store);
         let hasher = StarkPoseidonHasher::new(Some(false));
 

tests/mmr/core.rs

@@ -626,7 +626,9 @@ async fn should_append_to_poseidon_mmr() {
 
 #[tokio::test]
 async fn should_append_duplicate_to_mmr() {
-    let store = SQLiteStore::new(":memory:", None).await.unwrap();
+    let store = SQLiteStore::new(":memory:", None, Some("test"))
+        .await
+        .unwrap();
     let hasher = Arc::new(StarkPoseidonHasher::new(Some(false)));
 
     let store = Arc::new(store);

tests/mmr/draft.rs

@@ -134,7 +134,7 @@ async fn example() {
         hasher::stark_poseidon::StarkPoseidonHasher, mmr::MMR, store::memory::InMemoryStore,
     };
 
-    let store = InMemoryStore::new();
+    let store = InMemoryStore::new(Some("test"));
     let store = Arc::new(store);
     let hasher = Arc::new(StarkPoseidonHasher::new(Some(false)));
 

tests/mmr/stacked.rs

@@ -6,7 +6,9 @@ use accumulators::{
 
 #[tokio::test]
 async fn should_stack_two_mmrs() {
-    let store = SQLiteStore::new(":memory:", None).await.unwrap();
+    let store = SQLiteStore::new(":memory:", None, Some("test"))
+        .await
+        .unwrap();
     let hasher = Arc::new(StarkPoseidonHasher::new(Some(false)));
 
     let store = Arc::new(store);
@@ -67,7 +69,9 @@ async fn should_stack_two_mmrs() {
 
 #[tokio::test]
 async fn should_stack_4_mmrs() {
-    let store = SQLiteStore::new(":memory:", None).await.unwrap();
+    let store = SQLiteStore::new(":memory:", None, Some("test"))
+        .await
+        .unwrap();
     let hasher = Arc::new(StarkPoseidonHasher::new(Some(false)));
 
     let store = Arc::new(store);
@@ -212,7 +216,7 @@ async fn example() {
         hasher::stark_poseidon::StarkPoseidonHasher, mmr::MMR, store::memory::InMemoryStore,
     };
 
-    let store = InMemoryStore::new();
+    let store = InMemoryStore::new(Some("test"));
     let store = Arc::new(store);
     let hasher = Arc::new(StarkPoseidonHasher::new(Some(false)));
 

tests/store/sqlite.rs

@@ -6,7 +6,9 @@ use std::{collections::HashMap, sync::Arc};
 
 #[tokio::test]
 async fn set_and_get_value() {
-    let store = SQLiteStore::new(":memory:", None).await.unwrap();
+    let store = SQLiteStore::new(":memory:", None, Some("test"))
+        .await
+        .unwrap();
 
     let key_value = (
         "6b9b77f2-a893-48bf-a52a-d5be5d0aaba3:RootHash",
@@ -24,7 +26,9 @@ async fn set_and_get_value() {
 
 #[tokio::test]
 async fn set_and_get_many_values() {
-    let store = SQLiteStore::new(":memory:", None).await.unwrap();
+    let store = SQLiteStore::new(":memory:", None, Some("test"))
+        .await
+        .unwrap();
 
     let mut entries = HashMap::new();
     entries.insert("key1".to_string(), "value1".to_string());
@@ -39,7 +43,9 @@ async fn set_and_get_many_values() {
 
 #[tokio::test]
 async fn get_many_values_in_correct_order() {
-    let store = SQLiteStore::new(":memory:", None).await.unwrap();
+    let store = SQLiteStore::new(":memory:", None, Some("test"))
+        .await
+        .unwrap();
 
     let mut entries = HashMap::new();
     entries.insert("a".to_string(), "value1".to_string());
@@ -61,7 +67,9 @@ async fn get_many_values_in_correct_order() {
 
 #[tokio::test]
 async fn should_delete_a_value() {
-    let store = SQLiteStore::new(":memory:", None).await.unwrap();
+    let store = SQLiteStore::new(":memory:", None, Some("test"))
+        .await
+        .unwrap();
 
     store.set("key", "value").await.unwrap();
     store.delete("key").await.unwrap();
@@ -72,7 +80,9 @@ async fn should_delete_a_value() {
 
 #[tokio::test]
 async fn test_in_store_counter() {
-    let store = SQLiteStore::new(":memory:", None).await.unwrap();
+    let store = SQLiteStore::new(":memory:", None, Some("test"))
+        .await
+        .unwrap();
     let store = Arc::new(store);
 
     // Create an in-store counter
@@ -86,7 +96,9 @@ async fn test_in_store_counter() {
 
 #[tokio::test]
 async fn test_get_none_in_store_table() {
-    let store = SQLiteStore::new(":memory:", None).await.unwrap();
+    let store = SQLiteStore::new(":memory:", None, Some("test"))
+        .await
+        .unwrap();
 
     let store = Arc::new(store);
 
@@ -99,7 +111,9 @@ async fn test_get_none_in_store_table() {
 
 #[tokio::test]
 async fn test_get_many_none_in_store_table() {
-    let store = SQLiteStore::new(":memory:", None).await.unwrap();
+    let store = SQLiteStore::new(":memory:", None, Some("test"))
+        .await
+        .unwrap();
 
     let store = Arc::new(store);
 
@@ -127,7 +141,9 @@ async fn test_get_many_none_in_store_table() {
 
 #[tokio::test]
 async fn test_get_some_in_store_table() {
-    let store = SQLiteStore::new(":memory:", None).await.unwrap();
+    let store = SQLiteStore::new(":memory:", None, Some("test"))
+        .await
+        .unwrap();
 
     let store = Arc::new(store);