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::SerializationResult;
 use starknet_patricia_storage::map_storage::MapStorage;
 use starknet_patricia_storage::storage_trait::{
     create_db_key,
@@ -194,14 +195,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) -> SerializationResult<DbHashMap> {
+        let mut serialized_forest = DbHashMap::new();
+
+        // Storage tries.
+        for tree in filled_forest.storage_tries.values() {
+            serialized_forest.extend(tree.serialize(&EmptyKeyContext)?);
+        }
+
+        // Contracts and classes tries.
+        serialized_forest.extend(filled_forest.contracts_trie.serialize(&EmptyKeyContext)?);
+        serialized_forest.extend(filled_forest.classes_trie.serialize(&EmptyKeyContext)?);
+
+        Ok(serialized_forest)
     }
 
     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::SerializationResult;
 use starknet_patricia_storage::storage_trait::{DbHashMap, DbKey, DbValue, Storage};
 
 use crate::block_committer::input::{InputContext, ReaderConfig, 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) -> SerializationResult<DbHashMap>;
 
     /// 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) -> SerializationResult<usize> {
+        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);
+    ) -> SerializationResult<usize> {
+        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, SerializationResult};
 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) -> SerializationResult<DbValue> {
+        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) -> SerializationResult<DbValue> {
         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) -> SerializationResult<DbValue> {
         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_and_os_cli/src/committer_cli/commands.rs

@@ -38,7 +38,10 @@ pub async fn commit(input: FactsDbInputImpl, output_path: String, storage: MapSt
     let serialized_filled_forest = SerializedForest(
         commit_block(input, &mut facts_db, None).await.expect("Failed to commit the given block."),
     );
-    let output = serialized_filled_forest.forest_to_output().await;
+    let output = serialized_filled_forest
+        .forest_to_output()
+        .await
+        .expect("Failed to serialize filled forest");
     write_to_file(&output_path, &output);
     info!(
         "Successfully committed given block. Updated Contracts Trie Root Hash: {:?},

crates/starknet_committer_and_os_cli/src/committer_cli/filled_tree_output/filled_forest.rs

@@ -2,6 +2,7 @@ use serde::Serialize;
 use starknet_committer::db::facts_db::db::FactsDb;
 use starknet_committer::db::forest_trait::ForestWriter;
 use starknet_committer::forest::filled_forest::FilledForest;
+use starknet_patricia_storage::errors::SerializationResult;
 use starknet_patricia_storage::map_storage::MapStorage;
 
 pub struct SerializedForest(pub FilledForest);
@@ -19,16 +20,16 @@ pub struct Output {
 }
 
 impl SerializedForest {
-    pub async fn forest_to_output(&self) -> Output {
+    pub async fn forest_to_output(&self) -> SerializationResult<Output> {
         // Create an empty storage for the new facts.
         let mut output_facts_db = FactsDb::new(MapStorage::default());
-        output_facts_db.write(&self.0).await;
+        output_facts_db.write(&self.0).await?;
         let contract_storage_root_hash = self.0.get_contract_root_hash().0;
         let compiled_class_root_hash = self.0.get_compiled_class_root_hash().0;
-        Output {
+        Ok(Output {
             storage: output_facts_db.storage,
             contract_storage_root_hash: contract_storage_root_hash.to_hex_string(),
             compiled_class_root_hash: compiled_class_root_hash.to_hex_string(),
-        }
+        })
     }
 }

crates/starknet_committer_and_os_cli/src/committer_cli/tests/python_tests.rs

@@ -27,7 +27,7 @@ use starknet_patricia::patricia_merkle_tree::node_data::inner_node::{
 };
 use starknet_patricia::patricia_merkle_tree::types::SubTreeHeight;
 use starknet_patricia_storage::db_object::{DBObject, EmptyKeyContext};
-use starknet_patricia_storage::errors::DeserializationError;
+use starknet_patricia_storage::errors::{DeserializationError, SerializationError};
 use starknet_patricia_storage::map_storage::MapStorage;
 use starknet_patricia_storage::storage_trait::{DbKey, DbValue, Storage};
 use starknet_types_core::felt::Felt;
@@ -77,6 +77,8 @@ pub enum CommitterSpecificTestError {
     InvalidCastError(#[from] std::num::TryFromIntError),
     #[error(transparent)]
     DeserializationTestFailure(#[from] DeserializationError),
+    #[error(transparent)]
+    SerializationError(#[from] SerializationError),
 }
 
 /// Implements conversion from a string to the test runner.
@@ -191,8 +193,17 @@ fn serialize_for_rust_committer_flow_test(input: HashMap<String, String>) -> Str
     let TreeFlowInput { leaf_modifications, storage, root_hash } =
         parse_input_single_storage_tree_flow_test(&input);
     // Serialize the leaf modifications to an object that can be JSON-serialized.
-    let leaf_modifications_to_print: HashMap<String, Vec<u8>> =
-        leaf_modifications.into_iter().map(|(k, v)| (k.0.to_string(), v.serialize().0)).collect();
+    let leaf_modifications_to_print: HashMap<String, Vec<u8>> = leaf_modifications
+        .into_iter()
+        .map(|(k, v)| {
+            (
+                k.0.to_string(),
+                v.serialize()
+                    .unwrap_or_else(|error| panic!("Failed to serialize storage leaf: {error}"))
+                    .0,
+            )
+        })
+        .collect();
 
     // Create a json string to compare with the expected string in python.
     serde_json::to_string(&json!(
@@ -273,7 +284,9 @@ pub(crate) fn test_binary_serialize_test(binary_input: HashMap<String, u128>) ->
         FactDbFilledNode { data: NodeData::Binary(binary_data), hash: HashOutput(Felt::ZERO) };
 
     // Serialize the binary node and insert it into the map under the key "value".
-    let value = filled_node.serialize();
+    let value = filled_node
+        .serialize()
+        .unwrap_or_else(|error| panic!("Failed to serialize filled node: {error}"));
     map.insert("value".to_string(), value.0);
 
     // Serialize the map to a JSON string and handle serialization errors.
@@ -519,7 +532,16 @@ async fn test_storage_node(data: HashMap<String, String>) -> CommitterPythonTest
     };
 
     // Store the binary node in the storage.
-    rust_fact_storage.set(binary_rust.db_key(&EmptyKeyContext), binary_rust.serialize()).await?;
+    rust_fact_storage
+        .set(
+            binary_rust.db_key(&EmptyKeyContext),
+            binary_rust.serialize().map_err(|error| {
+                PythonTestError::SpecificError(CommitterSpecificTestError::SerializationError(
+                    error,
+                ))
+            })?,
+        )
+        .await?;
 
     // Parse the edge node data from the input.
     let edge_json = get_or_key_not_found(&data, "edge")?;
@@ -546,7 +568,16 @@ async fn test_storage_node(data: HashMap<String, String>) -> CommitterPythonTest
     };
 
     // Store the edge node in the storage.
-    rust_fact_storage.set(edge_rust.db_key(&EmptyKeyContext), edge_rust.serialize()).await?;
+    rust_fact_storage
+        .set(
+            edge_rust.db_key(&EmptyKeyContext),
+            edge_rust.serialize().map_err(|error| {
+                PythonTestError::SpecificError(CommitterSpecificTestError::SerializationError(
+                    error,
+                ))
+            })?,
+        )
+        .await?;
 
     // Parse the storage leaf data from the input.
     let storage_leaf_json = get_or_key_not_found(&data, "storage")?;
@@ -563,7 +594,14 @@ async fn test_storage_node(data: HashMap<String, String>) -> CommitterPythonTest
 
     // Store the storage leaf node in the storage.
     rust_fact_storage
-        .set(storage_leaf_rust.db_key(&EmptyKeyContext), storage_leaf_rust.serialize())
+        .set(
+            storage_leaf_rust.db_key(&EmptyKeyContext),
+            storage_leaf_rust.serialize().map_err(|error| {
+                PythonTestError::SpecificError(CommitterSpecificTestError::SerializationError(
+                    error,
+                ))
+            })?,
+        )
         .await?;
 
     // Parse the contract state leaf data from the input.
@@ -592,7 +630,11 @@ async fn test_storage_node(data: HashMap<String, String>) -> CommitterPythonTest
     rust_fact_storage
         .set(
             contract_state_leaf_rust.db_key(&EmptyKeyContext),
-            contract_state_leaf_rust.serialize(),
+            contract_state_leaf_rust.serialize().map_err(|error| {
+                PythonTestError::SpecificError(CommitterSpecificTestError::SerializationError(
+                    error,
+                ))
+            })?,
         )
         .await?;
 
@@ -614,7 +656,11 @@ async fn test_storage_node(data: HashMap<String, String>) -> CommitterPythonTest
     rust_fact_storage
         .set(
             compiled_class_leaf_rust.db_key(&EmptyKeyContext),
-            compiled_class_leaf_rust.serialize(),
+            compiled_class_leaf_rust.serialize().map_err(|error| {
+                PythonTestError::SpecificError(CommitterSpecificTestError::SerializationError(
+                    error,
+                ))
+            })?,
         )
         .await?;
 
@@ -625,7 +671,9 @@ async fn test_storage_node(data: HashMap<String, String>) -> CommitterPythonTest
 /// Generates a dummy random filled forest and serializes it to a JSON string.
 pub(crate) async fn filled_forest_output_test() -> CommitterPythonTestResult {
     let dummy_forest = SerializedForest(FilledForest::dummy_random(&mut rand::thread_rng(), None));
-    let output = dummy_forest.forest_to_output().await;
+    let output = dummy_forest.forest_to_output().await.map_err(|error| {
+        PythonTestError::SpecificError(CommitterSpecificTestError::SerializationError(error))
+    })?;
     let output_string = serde_json::to_string(&output).expect("Failed to serialize");
     Ok(output_string)
 }