starknet_committer,starknet_patricia: add serde errors

Author: ArielElp

crates/starknet_committer/src/db/external_test_utils.rs

@@ -91,7 +91,7 @@ pub async fn single_tree_flow_test<
     let json_hash = &json!(hash_result.0.to_hex_string());
     result_map.insert("root_hash", json_hash);
     // Serlialize the storage modifications.
-    let json_storage = &json!(filled_tree.serialize(&EmptyKeyContext));
+    let json_storage = &json!(filled_tree.serialize(&EmptyKeyContext).unwrap());
     result_map.insert("storage_changes", json_storage);
     serde_json::to_string(&result_map).expect("serialization failed")
 }

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

@@ -226,7 +226,7 @@ async fn test_create_tree(
 
 pub(crate) fn create_mock_leaf_entry(val: u128) -> (DbKey, DbValue) {
     let leaf = MockLeaf(Felt::from(val));
-    (leaf.get_db_key(&EmptyKeyContext, &leaf.0.to_bytes_be()), leaf.serialize())
+    (leaf.get_db_key(&EmptyKeyContext, &leaf.0.to_bytes_be()), leaf.serialize().unwrap())
 }
 
 fn create_mock_leaf_modifications(

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

@@ -9,6 +9,7 @@ use starknet_patricia::patricia_merkle_tree::node_data::leaf::{Leaf, LeafModific
 use starknet_patricia::patricia_merkle_tree::original_skeleton_tree::tree::OriginalSkeletonTreeImpl;
 use starknet_patricia::patricia_merkle_tree::types::{NodeIndex, SortedLeafIndices};
 use starknet_patricia_storage::db_object::EmptyKeyContext;
+use starknet_patricia_storage::errors::SerializationError;
 use starknet_patricia_storage::map_storage::MapStorage;
 use starknet_patricia_storage::storage_trait::{
     create_db_key,
@@ -189,14 +190,19 @@ impl<S: Storage> ForestReader<FactsDbInitialRead> for FactsDb<S> {
 
 #[async_trait]
 impl<S: Storage> ForestWriter for FactsDb<S> {
-    fn serialize_forest(filled_forest: &FilledForest) -> DbHashMap {
-        filled_forest
-            .storage_tries
-            .values()
-            .flat_map(|tree| tree.serialize(&EmptyKeyContext).into_iter())
-            .chain(filled_forest.contracts_trie.serialize(&EmptyKeyContext))
-            .chain(filled_forest.classes_trie.serialize(&EmptyKeyContext))
-            .collect()
+    fn serialize_forest(filled_forest: &FilledForest) -> Result<DbHashMap, SerializationError> {
+        let mut out = DbHashMap::new();
+
+        // storage tries
+        for tree in filled_forest.storage_tries.values() {
+            out.extend(tree.serialize(&EmptyKeyContext)?);
+        }
+
+        // other tries
+        out.extend(filled_forest.contracts_trie.serialize(&EmptyKeyContext)?);
+        out.extend(filled_forest.classes_trie.serialize(&EmptyKeyContext)?);
+
+        Ok(out)
     }
 
     async fn write_updates(&mut self, updates: DbHashMap) -> usize {

crates/starknet_committer/src/db/forest_trait.rs

@@ -5,6 +5,7 @@ use starknet_api::block::BlockNumber;
 use starknet_api::core::ContractAddress;
 use starknet_patricia::patricia_merkle_tree::node_data::leaf::LeafModifications;
 use starknet_patricia::patricia_merkle_tree::types::NodeIndex;
+use starknet_patricia_storage::errors::SerializationError;
 use starknet_patricia_storage::storage_trait::{DbHashMap, DbKey, DbValue, Storage};
 
 use crate::block_committer::input::{ConfigImpl, InputContext, StarknetStorageValue};
@@ -63,28 +64,28 @@ pub trait ForestReader<I: InputContext> {
 #[async_trait]
 pub trait ForestWriter: ForestMetadata + Send {
     /// Serializes a filled forest into a hash map.
-    fn serialize_forest(filled_forest: &FilledForest) -> DbHashMap;
+    fn serialize_forest(filled_forest: &FilledForest) -> Result<DbHashMap, SerializationError>;
 
     /// Writes the updates map to storage. Returns the number of new updates written to storage.
     async fn write_updates(&mut self, updates: DbHashMap) -> usize;
 
     /// Writes the serialized filled forest to storage. Returns the number of new updates written to
     /// storage.
-    async fn write(&mut self, filled_forest: &FilledForest) -> usize {
-        let updates = Self::serialize_forest(filled_forest);
-        self.write_updates(updates).await
+    async fn write(&mut self, filled_forest: &FilledForest) -> Result<usize, SerializationError> {
+        let updates = Self::serialize_forest(filled_forest)?;
+        Ok(self.write_updates(updates).await)
     }
 
     async fn write_with_metadata(
         &mut self,
         filled_forest: &FilledForest,
         metadata: HashMap<ForestMetadataType, DbValue>,
-    ) -> usize {
-        let mut updates = Self::serialize_forest(filled_forest);
+    ) -> Result<usize, SerializationError> {
+        let mut updates = Self::serialize_forest(filled_forest)?;
         for (metadata_type, value) in metadata {
             Self::insert_metadata(&mut updates, metadata_type, value);
         }
-        self.write_updates(updates).await
+        Ok(self.write_updates(updates).await)
     }
 }
 

crates/starknet_committer/src/forest/skeleton_forest_test.rs

@@ -51,12 +51,12 @@ macro_rules! compare_skeleton_tree {
 
 pub(crate) fn create_storage_leaf_entry(val: u128) -> (DbKey, DbValue) {
     let leaf = StarknetStorageValue(Felt::from(val));
-    (leaf.get_db_key(&EmptyKeyContext, &leaf.0.to_bytes_be()), leaf.serialize())
+    (leaf.get_db_key(&EmptyKeyContext, &leaf.0.to_bytes_be()), leaf.serialize().unwrap())
 }
 
 pub(crate) fn create_compiled_class_leaf_entry(val: u128) -> (DbKey, DbValue) {
     let leaf = CompiledClassHash(Felt::from(val));
-    (leaf.get_db_key(&EmptyKeyContext, &leaf.0.to_bytes_be()), leaf.serialize())
+    (leaf.get_db_key(&EmptyKeyContext, &leaf.0.to_bytes_be()), leaf.serialize().unwrap())
 }
 
 pub(crate) fn create_contract_state_leaf_entry(val: u128) -> (DbKey, DbValue) {
@@ -66,7 +66,7 @@ pub(crate) fn create_contract_state_leaf_entry(val: u128) -> (DbKey, DbValue) {
         storage_root_hash: HashOutput(felt),
         class_hash: ClassHash(felt),
     };
-    (leaf.get_db_key(&EmptyKeyContext, &felt.to_bytes_be()), leaf.serialize())
+    (leaf.get_db_key(&EmptyKeyContext, &felt.to_bytes_be()), leaf.serialize().unwrap())
 }
 
 // This test uses addition hash for simplicity (i.e hash(a,b) = a + b).

crates/starknet_committer/src/patricia_merkle_tree/leaf/leaf_serde.rs

@@ -5,7 +5,7 @@ use starknet_api::core::{ClassHash, Nonce};
 use starknet_api::hash::HashOutput;
 use starknet_patricia::patricia_merkle_tree::types::SubTreeHeight;
 use starknet_patricia_storage::db_object::{DBObject, EmptyDeserializationContext};
-use starknet_patricia_storage::errors::DeserializationError;
+use starknet_patricia_storage::errors::{DeserializationError, SerializationError};
 use starknet_patricia_storage::storage_trait::{DbKeyPrefix, DbValue};
 use starknet_types_core::felt::Felt;
 
@@ -34,8 +34,8 @@ impl DBObject for StarknetStorageValue {
     type DeserializeContext = EmptyDeserializationContext;
 
     /// Serializes the value into a 32-byte vector.
-    fn serialize(&self) -> DbValue {
-        DbValue(self.0.to_bytes_be().to_vec())
+    fn serialize(&self) -> Result<DbValue, SerializationError> {
+        Ok(DbValue(self.0.to_bytes_be().to_vec()))
     }
 
     fn deserialize(
@@ -50,9 +50,9 @@ impl DBObject for CompiledClassHash {
     type DeserializeContext = EmptyDeserializationContext;
 
     /// Creates a json string describing the leaf and casts it into a byte vector.
-    fn serialize(&self) -> DbValue {
+    fn serialize(&self) -> Result<DbValue, SerializationError> {
         let json_string = format!(r#"{{"compiled_class_hash": "{}"}}"#, self.0.to_hex_string());
-        DbValue(json_string.into_bytes())
+        Ok(DbValue(json_string.into_bytes()))
     }
 
     fn deserialize(
@@ -72,15 +72,15 @@ impl DBObject for ContractState {
     type DeserializeContext = EmptyDeserializationContext;
 
     /// Creates a json string describing the leaf and casts it into a byte vector.
-    fn serialize(&self) -> DbValue {
+    fn serialize(&self) -> Result<DbValue, SerializationError> {
         let json_string = format!(
             r#"{{"contract_hash": "{}", "storage_commitment_tree": {{"root": "{}", "height": {}}}, "nonce": "{}"}}"#,
             fixed_hex_string_no_prefix(&self.class_hash.0),
             fixed_hex_string_no_prefix(&self.storage_root_hash.0),
             SubTreeHeight::ACTUAL_HEIGHT,
             self.nonce.0.to_hex_string(),
         );
-        DbValue(json_string.into_bytes())
+        Ok(DbValue(json_string.into_bytes()))
     }
 
     fn deserialize(

crates/starknet_committer/src/patricia_merkle_tree/leaf/leaf_serde_test.rs

@@ -31,7 +31,7 @@ use crate::patricia_merkle_tree::types::CompiledClassHash;
    })
 ]
 fn test_leaf_serde<L: Leaf + Eq + Debug>(#[case] leaf: L) {
-    let serialized = leaf.serialize();
+    let serialized = leaf.serialize().unwrap();
     let deserialized = L::deserialize(&serialized, &EmptyDeserializationContext).unwrap();
     assert_eq!(deserialized, leaf);
 }

crates/starknet_committer_cli/src/commands.rs

@@ -360,7 +360,7 @@ pub async fn run_storage_benchmark<S: Storage>(
             .await
             .expect("Failed to commit the given block.");
         time_measurement.start_measurement(Action::Write);
-        let n_new_facts = facts_db.write(&filled_forest).await;
+        let n_new_facts = facts_db.write(&filled_forest).await.unwrap();
         info!("Written {n_new_facts} new facts to storage");
         time_measurement.stop_measurement(None, Action::Write);
 

crates/starknet_patricia/src/patricia_merkle_tree/external_test_utils.rs

@@ -10,7 +10,7 @@ use starknet_patricia_storage::db_object::{
     EmptyKeyContext,
     HasStaticPrefix,
 };
-use starknet_patricia_storage::errors::DeserializationError;
+use starknet_patricia_storage::errors::{DeserializationError, SerializationError};
 use starknet_patricia_storage::storage_trait::{create_db_key, DbKey, DbKeyPrefix, DbValue};
 use starknet_types_core::felt::Felt;
 use starknet_types_core::hash::StarkHash;
@@ -39,8 +39,8 @@ impl HasStaticPrefix for MockLeaf {
 impl DBObject for MockLeaf {
     type DeserializeContext = EmptyDeserializationContext;
 
-    fn serialize(&self) -> DbValue {
-        DbValue(self.0.to_bytes_be().to_vec())
+    fn serialize(&self) -> Result<DbValue, SerializationError> {
+        Ok(DbValue(self.0.to_bytes_be().to_vec()))
     }
 
     fn deserialize(

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

@@ -6,7 +6,7 @@ use starknet_patricia_storage::db_object::{
     HasDynamicPrefix,
     HasStaticPrefix,
 };
-use starknet_patricia_storage::errors::DeserializationError;
+use starknet_patricia_storage::errors::{DeserializationError, SerializationError};
 use starknet_patricia_storage::storage_trait::{DbKey, DbKeyPrefix, DbValue};
 use starknet_types_core::felt::Felt;
 
@@ -82,7 +82,7 @@ impl<L: Leaf> DBObject for FactDbFilledNode<L> {
     /// - For binary nodes: Concatenates left and right hashes.
     /// - For edge nodes: Concatenates bottom hash, path, and path length.
     /// - For leaf nodes: use leaf.serialize() method.
-    fn serialize(&self) -> DbValue {
+    fn serialize(&self) -> Result<DbValue, SerializationError> {
         match &self.data {
             NodeData::Binary(BinaryData { left_data: left_hash, right_data: right_hash }) => {
                 // Serialize left and right hashes to byte arrays.
@@ -91,7 +91,7 @@ impl<L: Leaf> DBObject for FactDbFilledNode<L> {
 
                 // Concatenate left and right hashes.
                 let serialized = [left, right].concat();
-                DbValue(serialized)
+                Ok(DbValue(serialized))
             }
 
             NodeData::Edge(EdgeData { bottom_data: bottom_hash, path_to_bottom }) => {
@@ -103,7 +103,7 @@ impl<L: Leaf> DBObject for FactDbFilledNode<L> {
 
                 // Concatenate bottom hash, path, and path length.
                 let serialized = [bottom.to_vec(), path.to_vec(), length.to_vec()].concat();
-                DbValue(serialized)
+                Ok(DbValue(serialized))
             }
 
             NodeData::Leaf(leaf_data) => leaf_data.serialize(),