starknet_committer: db layout trait

Author: ArielElp

crates/starknet_committer/src/db.rs

@@ -1,3 +1,4 @@
+pub mod db_layout;
 #[cfg(any(feature = "testing", test))]
 pub mod external_test_utils;
 pub mod facts_db;

crates/starknet_committer/src/db/db_layout.rs

@@ -0,0 +1,21 @@
+use starknet_api::core::ContractAddress;
+use starknet_patricia::db_layout::NodeLayoutFor;
+use starknet_patricia::patricia_merkle_tree::node_data::leaf::Leaf;
+use starknet_patricia_storage::db_object::{EmptyKeyContext, HasStaticPrefix};
+
+use crate::block_committer::input::StarknetStorageValue;
+use crate::patricia_merkle_tree::leaf::leaf_impl::ContractState;
+use crate::patricia_merkle_tree::types::CompiledClassHash;
+
+/// A trait that specifies, for every leaf type, its db representation and the node layout for it.
+pub trait DbLayout {
+    type ContractStateDbLeaf: Leaf + HasStaticPrefix<KeyContext = EmptyKeyContext>;
+
+    type CompiledClassHashDbLeaf: Leaf + HasStaticPrefix<KeyContext = EmptyKeyContext>;
+
+    type StarknetStorageValueDbLeaf: Leaf + HasStaticPrefix<KeyContext = ContractAddress>;
+
+    type NodeLayout: NodeLayoutFor<ContractState, DbLeaf = Self::ContractStateDbLeaf>
+        + NodeLayoutFor<CompiledClassHash, DbLeaf = Self::CompiledClassHashDbLeaf>
+        + NodeLayoutFor<StarknetStorageValue, DbLeaf = Self::StarknetStorageValueDbLeaf>;
+}

crates/starknet_committer/src/db/facts_db/db.rs

@@ -14,6 +14,7 @@ use starknet_patricia_storage::map_storage::MapStorage;
 use starknet_patricia_storage::storage_trait::{DbHashMap, DbKey, Storage};
 
 use crate::block_committer::input::{ReaderConfig, StarknetStorageValue};
+use crate::db::db_layout::DbLayout;
 use crate::db::facts_db::types::{FactsDbInitialRead, FactsSubTree};
 use crate::db::forest_trait::{read_forest, serialize_forest, ForestReader, ForestWriter};
 use crate::forest::filled_forest::FilledForest;
@@ -64,6 +65,13 @@ impl NodeLayoutFor<CompiledClassHash> for FactsNodeLayout {
     type DbLeaf = CompiledClassHash;
 }
 
+impl DbLayout for FactsNodeLayout {
+    type ContractStateDbLeaf = ContractState;
+    type CompiledClassHashDbLeaf = CompiledClassHash;
+    type StarknetStorageValueDbLeaf = StarknetStorageValue;
+    type NodeLayout = FactsNodeLayout;
+}
+
 pub struct FactsDb<S: Storage> {
     // TODO(Yoav): Define StorageStats trait and impl it here. Then, make the storage field
     // private.

crates/starknet_committer/src/db/forest_trait.rs

@@ -3,15 +3,15 @@ use std::collections::HashMap;
 use async_trait::async_trait;
 use serde::{Deserialize, Serialize};
 use starknet_api::core::ContractAddress;
-use starknet_patricia::db_layout::NodeLayoutFor;
 use starknet_patricia::patricia_merkle_tree::filled_tree::tree::FilledTree;
 use starknet_patricia::patricia_merkle_tree::node_data::leaf::LeafModifications;
 use starknet_patricia::patricia_merkle_tree::types::NodeIndex;
-use starknet_patricia_storage::db_object::{EmptyKeyContext, HasStaticPrefix};
+use starknet_patricia_storage::db_object::EmptyKeyContext;
 use starknet_patricia_storage::errors::SerializationResult;
 use starknet_patricia_storage::storage_trait::{DbHashMap, DbKey, DbValue, Storage};
 
 use crate::block_committer::input::{InputContext, ReaderConfig, StarknetStorageValue};
+use crate::db::db_layout::DbLayout;
 use crate::db::facts_db::types::FactsDbInitialRead;
 use crate::db::serde_db_utils::DbBlockNumber;
 use crate::db::trie_traversal::{create_classes_trie, create_contracts_trie, create_storage_tries};
@@ -81,30 +81,24 @@ pub(crate) async fn read_forest<'a, S, Layout>(
 ) -> ForestResult<(OriginalSkeletonForest<'a>, HashMap<NodeIndex, ContractState>)>
 where
     S: Storage,
-    Layout: NodeLayoutFor<StarknetStorageValue>
-        + NodeLayoutFor<ContractState>
-        + NodeLayoutFor<CompiledClassHash>,
-    <Layout as NodeLayoutFor<StarknetStorageValue>>::DbLeaf:
-        HasStaticPrefix<KeyContext = ContractAddress>,
-    <Layout as NodeLayoutFor<ContractState>>::DbLeaf: HasStaticPrefix<KeyContext = EmptyKeyContext>,
-    <Layout as NodeLayoutFor<CompiledClassHash>>::DbLeaf:
-        HasStaticPrefix<KeyContext = EmptyKeyContext>,
+    Layout: DbLayout,
 {
-    let (contracts_trie, original_contracts_trie_leaves) = create_contracts_trie::<Layout>(
-        storage,
-        context.0.contracts_trie_root_hash,
-        forest_sorted_indices.contracts_trie_sorted_indices,
-    )
-    .await?;
-    let storage_tries = create_storage_tries::<Layout>(
+    let (contracts_trie, original_contracts_trie_leaves) =
+        create_contracts_trie::<Layout::NodeLayout>(
+            storage,
+            context.0.contracts_trie_root_hash,
+            forest_sorted_indices.contracts_trie_sorted_indices,
+        )
+        .await?;
+    let storage_tries = create_storage_tries::<Layout::NodeLayout>(
         storage,
         storage_updates,
         &original_contracts_trie_leaves,
         &config,
         &forest_sorted_indices.storage_tries_sorted_indices,
     )
     .await?;
-    let classes_trie = create_classes_trie::<Layout>(
+    let classes_trie = create_classes_trie::<Layout::NodeLayout>(
         storage,
         classes_updates,
         context.0.classes_trie_root_hash,
@@ -120,31 +114,23 @@ where
 }
 
 /// Helper function containing layout-common write logic.
-pub(crate) fn serialize_forest<Layout>(
+pub(crate) fn serialize_forest<Layout: DbLayout>(
     filled_forest: &FilledForest,
-) -> SerializationResult<DbHashMap>
-where
-    Layout: NodeLayoutFor<StarknetStorageValue>
-        + NodeLayoutFor<ContractState>
-        + NodeLayoutFor<CompiledClassHash>,
-    <Layout as NodeLayoutFor<StarknetStorageValue>>::DbLeaf:
-        HasStaticPrefix<KeyContext = ContractAddress>,
-    <Layout as NodeLayoutFor<ContractState>>::DbLeaf: HasStaticPrefix<KeyContext = EmptyKeyContext>,
-    <Layout as NodeLayoutFor<CompiledClassHash>>::DbLeaf:
-        HasStaticPrefix<KeyContext = EmptyKeyContext>,
-{
+) -> SerializationResult<DbHashMap> {
     let mut serialized_forest = DbHashMap::new();
 
     // Storage tries.
     for (contract_address, tree) in &filled_forest.storage_tries {
-        serialized_forest.extend(tree.serialize::<Layout>(contract_address)?);
+        serialized_forest.extend(tree.serialize::<Layout::NodeLayout>(contract_address)?);
     }
 
     // Contracts trie.
-    serialized_forest.extend(filled_forest.contracts_trie.serialize::<Layout>(&EmptyKeyContext)?);
+    serialized_forest
+        .extend(filled_forest.contracts_trie.serialize::<Layout::NodeLayout>(&EmptyKeyContext)?);
 
     // Classes trie.
-    serialized_forest.extend(filled_forest.classes_trie.serialize::<Layout>(&EmptyKeyContext)?);
+    serialized_forest
+        .extend(filled_forest.classes_trie.serialize::<Layout::NodeLayout>(&EmptyKeyContext)?);
 
     Ok(serialized_forest)
 }

crates/starknet_committer/src/db/index_db/db.rs

@@ -13,6 +13,7 @@ use starknet_patricia_storage::errors::SerializationResult;
 use starknet_patricia_storage::storage_trait::{DbHashMap, DbKey, Storage};
 
 use crate::block_committer::input::{ReaderConfig, StarknetStorageValue};
+use crate::db::db_layout::DbLayout;
 use crate::db::facts_db::types::FactsDbInitialRead;
 use crate::db::forest_trait::{read_forest, serialize_forest, ForestReader, ForestWriter};
 use crate::db::index_db::leaves::{
@@ -83,6 +84,13 @@ impl NodeLayoutFor<CompiledClassHash> for IndexNodeLayout {
     type DbLeaf = IndexLayoutCompiledClassHash;
 }
 
+impl DbLayout for IndexNodeLayout {
+    type ContractStateDbLeaf = IndexLayoutContractState;
+    type CompiledClassHashDbLeaf = IndexLayoutCompiledClassHash;
+    type StarknetStorageValueDbLeaf = IndexLayoutStarknetStorageValue;
+    type NodeLayout = IndexNodeLayout;
+}
+
 // TODO(Ariel): define an IndexDbInitialRead empty type, and check whether each tree is empty inside
 // create_xxx_trie.
 #[async_trait]