refactor: removed duplicate definitions of storage prefixes

crates/committer/src/patricia_merkle_tree/filled_tree/node_serde.rs

@@ -1,9 +1,11 @@
 use crate::hash::hash_trait::HashOutput;
-use crate::patricia_merkle_tree::filled_tree::node::{BinaryData, FilledNode, LeafData, NodeData};
+use crate::patricia_merkle_tree::filled_tree::node::FilledNode;
+use crate::patricia_merkle_tree::filled_tree::node::{BinaryData, LeafData, NodeData};
 use crate::patricia_merkle_tree::filled_tree::tree::FilledTreeResult;
 use crate::patricia_merkle_tree::original_skeleton_tree::tree::OriginalSkeletonTreeResult;
-use crate::patricia_merkle_tree::types::{EdgeData, EdgePath, EdgePathLength, PathToBottom};
-use crate::storage::storage_trait::{create_db_key, StorageKey, StorageValue};
+use crate::patricia_merkle_tree::types::EdgeData;
+use crate::patricia_merkle_tree::types::{EdgePath, EdgePathLength, PathToBottom};
+use crate::storage::storage_trait::{create_db_key, StorageKey, StoragePrefix, StorageValue};
 use crate::types::Felt;
 use serde::{Deserialize, Serialize};
 
@@ -23,12 +25,6 @@ pub(crate) const STORAGE_LEAF_SIZE: usize = SERIALIZE_HASH_BYTES;
 // TODO(Aviv, 17/4/2024): add CompiledClassLeaf size.
 // TODO(Aviv, 17/4/2024): add StateTreeLeaf size.
 
-// Const describe the prefix of the serialized node.
-pub(crate) const STORAGE_LEAF_PREFIX: &[u8; 21] = b"starknet_storage_leaf";
-pub(crate) const STATE_TREE_LEAF_PREFIX: &[u8; 14] = b"contract_state";
-pub(crate) const COMPLIED_CLASS_PREFIX: &[u8; 19] = b"contract_class_leaf";
-pub(crate) const INNER_NODE_PREFIX: &[u8; 13] = b"patricia_node";
-
 /// Enum to describe the serialized node.
 #[allow(dead_code)]
 pub(crate) enum SerializeNode {
@@ -97,15 +93,17 @@ impl FilledNode<LeafData> {
         let suffix = self.suffix();
 
         match &self.data {
-            NodeData::Binary(_) | NodeData::Edge(_) => create_db_key(INNER_NODE_PREFIX, &suffix),
+            NodeData::Binary(_) | NodeData::Edge(_) => {
+                create_db_key(StoragePrefix::InnerNode, &suffix)
+            }
             NodeData::Leaf(LeafData::StorageValue(_)) => {
-                create_db_key(STORAGE_LEAF_PREFIX, &suffix)
+                create_db_key(StoragePrefix::StorageLeaf, &suffix)
             }
             NodeData::Leaf(LeafData::CompiledClassHash(_)) => {
-                create_db_key(COMPLIED_CLASS_PREFIX, &suffix)
+                create_db_key(StoragePrefix::CompiledClassLeaf, &suffix)
             }
             NodeData::Leaf(LeafData::StateTreeTuple { .. }) => {
-                create_db_key(STATE_TREE_LEAF_PREFIX, &suffix)
+                create_db_key(StoragePrefix::StateTreeLeaf, &suffix)
             }
         }
     }

crates/committer/src/patricia_merkle_tree/original_skeleton_tree/original_skeleton_calc.rs

@@ -13,6 +13,7 @@ use crate::patricia_merkle_tree::{
     original_skeleton_tree::node::OriginalSkeletonNode, types::NodeIndex,
 };
 use crate::storage::errors::StorageError;
+use crate::storage::storage_trait::create_db_key;
 use crate::storage::storage_trait::Storage;
 use crate::storage::storage_trait::StorageKey;
 use crate::storage::storage_trait::StoragePrefix;
@@ -189,8 +190,7 @@ impl OriginalSkeletonTreeImpl {
     ) -> OriginalSkeletonTreeResult<Vec<FilledNode<LeafData>>> {
         let mut subtrees_roots = vec![];
         for subtree in subtrees.iter() {
-            let key =
-                StorageKey::from(subtree.root_hash.0).with_prefix(StoragePrefix::PatriciaNode);
+            let key = create_db_key(StoragePrefix::InnerNode, &subtree.root_hash.0.as_bytes());
             let val = storage.get(&key).ok_or(StorageError::MissingKey(key))?;
             subtrees_roots.push(FilledNode::deserialize(
                 &StorageKey::from(subtree.root_hash.0),

crates/committer/src/patricia_merkle_tree/original_skeleton_tree/original_skeleton_calc_test.rs

@@ -259,7 +259,7 @@ fn create_32_bytes_entry(simple_val: u8) -> Vec<u8> {
 }
 
 fn create_patricia_key(val: u8) -> StorageKey {
-    StorageKey(create_32_bytes_entry(val)).with_prefix(StoragePrefix::PatriciaNode)
+    StorageKey(create_32_bytes_entry(val)).with_prefix(StoragePrefix::InnerNode)
 }
 
 fn create_binary_val(left: u8, right: u8) -> StorageValue {

crates/committer/src/storage/storage_trait.rs

@@ -29,22 +29,28 @@ pub(crate) trait Storage {
 }
 
 pub(crate) enum StoragePrefix {
-    PatriciaNode,
+    InnerNode,
+    StorageLeaf,
+    StateTreeLeaf,
+    CompiledClassLeaf,
 }
 
+/// Describes a storage prefix as used in Aerospike DB.
 impl StoragePrefix {
-    pub(crate) fn to_bytes(&self) -> &[u8] {
+    pub(crate) fn to_bytes(&self) -> &'static [u8] {
         match self {
-            Self::PatriciaNode => "patricia_node:".as_bytes(),
+            Self::InnerNode => b"patricia_node",
+            Self::StorageLeaf => b"starknet_storage_leaf",
+            Self::StateTreeLeaf => b"contract_state",
+            Self::CompiledClassLeaf => b"contract_class_leaf",
         }
     }
 }
 
+#[cfg(test)]
 impl StorageKey {
     pub(crate) fn with_prefix(&self, prefix: StoragePrefix) -> Self {
-        let mut prefix = prefix.to_bytes().to_vec();
-        prefix.extend(&self.0);
-        StorageKey(prefix)
+        create_db_key(prefix, &self.0)
     }
 }
 
@@ -55,6 +61,6 @@ impl From<Felt> for StorageKey {
 }
 
 /// Returns a `StorageKey` from a prefix and a suffix.
-pub(crate) fn create_db_key(prefix: &[u8], suffix: &[u8]) -> StorageKey {
-    StorageKey([prefix.to_vec(), b":".to_vec(), suffix.to_vec()].concat())
+pub(crate) fn create_db_key(prefix: StoragePrefix, suffix: &[u8]) -> StorageKey {
+    StorageKey([prefix.to_bytes().to_vec(), b":".to_vec(), suffix.to_vec()].concat())
 }