build: impl main committer logic

crates/committer/src/block_committer/commit.rs

@@ -17,7 +17,7 @@ use crate::storage::map_storage::MapStorage;
 type BlockCommitmentResult<T> = Result<T, BlockCommitmentError<LeafDataImpl>>;
 
 #[allow(dead_code)]
-pub(crate) async fn commit_block(input: Input) -> BlockCommitmentResult<()> {
+pub async fn commit_block(input: Input) -> BlockCommitmentResult<FilledForestImpl> {
     let mut original_forest = OriginalSkeletonForestImpl::<OriginalSkeletonTreeImpl>::create(
         MapStorage::from(input.storage),
         input.contracts_trie_root_hash,
@@ -42,19 +42,19 @@ pub(crate) async fn commit_block(input: Input) -> BlockCommitmentResult<()> {
         input.tree_heights,
     )?;
 
-    let _filled_forest = FilledForestImpl::create::<UpdatedSkeletonTreeImpl, TreeHashFunctionImpl>(
-        updated_forest,
-        input.state_diff.actual_storage_updates(input.tree_heights),
-        StateDiff::actual_classes_updates(
-            &input.state_diff.class_hash_to_compiled_class_hash,
+    Ok(
+        FilledForestImpl::create::<UpdatedSkeletonTreeImpl, TreeHashFunctionImpl>(
+            updated_forest,
+            input.state_diff.actual_storage_updates(input.tree_heights),
+            StateDiff::actual_classes_updates(
+                &input.state_diff.class_hash_to_compiled_class_hash,
+                input.tree_heights,
+            ),
+            &input.current_contracts_trie_leaves,
+            &input.state_diff.address_to_class_hash,
+            &input.state_diff.address_to_nonce,
             input.tree_heights,
-        ),
-        &input.current_contracts_trie_leaves,
-        &input.state_diff.address_to_class_hash,
-        &input.state_diff.address_to_nonce,
-        input.tree_heights,
+        )
+        .await?,
     )
-    .await?;
-
-    todo!()
 }

crates/committer/src/block_committer/errors.rs

@@ -3,7 +3,7 @@ use thiserror::Error;
 use crate::{forest_errors::ForestError, patricia_merkle_tree::node_data::leaf::LeafData};
 
 #[derive(Debug, Error)]
-pub(crate) enum BlockCommitmentError<L: LeafData> {
+pub enum BlockCommitmentError<L: LeafData> {
     #[error(transparent)]
     ForestError(#[from] ForestError<L>),
 }

crates/committer/src/forest_errors.rs

@@ -10,7 +10,7 @@ use tokio::task::JoinError;
 pub(crate) type ForestResult<T> = Result<T, ForestError<LeafDataImpl>>;
 
 #[derive(Debug, Error)]
-pub(crate) enum ForestError<L: LeafData> {
+pub enum ForestError<L: LeafData> {
     #[error(transparent)]
     OriginalSkeleton(#[from] OriginalSkeletonTreeError),
     #[error(transparent)]

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

@@ -5,7 +5,7 @@ use thiserror::Error;
 use crate::storage::errors::{DeserializationError, StorageError};
 
 #[derive(Debug, Error)]
-pub(crate) enum OriginalSkeletonTreeError {
+pub enum OriginalSkeletonTreeError {
     #[error(
         "Failed to deserialize the storage value: {0:?} while building the original skeleton tree."
     )]

crates/committer/src/storage/errors.rs

@@ -3,7 +3,7 @@ use serde_json;
 use thiserror::Error;
 
 #[derive(Debug, Error)]
-pub(crate) enum StorageError {
+pub enum StorageError {
     #[error("The key {0:?} does not exist in storage.")]
     MissingKey(StorageKey),
 }

crates/committer_cli/Cargo.toml

@@ -25,3 +25,4 @@ starknet-types-core.workspace = true
 strum.workspace = true
 strum_macros.workspace = true
 thiserror.workspace = true
+tokio.workspace = true

crates/committer_cli/src/main.rs

@@ -1,6 +1,9 @@
 use crate::tests::python_tests::PythonTest;
 use clap::{Args, Parser, Subcommand};
-use std::path::Path;
+use committer::block_committer::commit::commit_block;
+use filled_tree_output::filled_forest::SerializedForest;
+use parse_input::read::parse_input;
+use std::io;
 
 pub mod filled_tree_output;
 pub mod parse_input;
@@ -43,28 +46,28 @@ enum Command {
 #[derive(Debug, Args)]
 struct GlobalOptions {}
 
+#[tokio::main]
 /// Main entry point of the committer CLI.
-fn main() {
+async fn main() {
     let args = CommitterCliArgs::parse();
 
     match args.command {
         Command::Commit {
-            input_path,
-            output_path,
+            input_path: _input_path,
+            output_path: _output_path,
         } => {
-            let input_file_name = Path::new(&input_path);
-            let output_file_name = Path::new(&output_path);
-            assert!(
-                input_file_name.is_absolute() && output_file_name.is_absolute(),
-                "Given paths must be absolute."
+            // TODO(Nimrod, 20/6/2024): Allow read/write from file path.
+            let input =
+                parse_input(io::read_to_string(io::stdin()).expect("Failed to read from stdin."))
+                    .expect("Failed to parse the given input.");
+            let serialized_filled_forest = SerializedForest(
+                commit_block(input)
+                    .await
+                    .expect("Failed to commit the given block."),
             );
-
-            // Business logic to be implemented here.
-            let output = std::fs::read(input_file_name)
-                .unwrap_or_else(|_| panic!("Failed to read input from file '{input_file_name:?}'"));
-
-            // Output to file.
-            std::fs::write(output_file_name, output).expect("Failed to write output");
+            serialized_filled_forest
+                .forest_to_python()
+                .expect("Failed to print new facts to python.");
         }
 
         Command::PythonTest { test_name, inputs } => {