apollo_proof_manager: create proof manager

Author: einat-starkware

crates/apollo_proof_manager/src/lib.rs

@@ -1,3 +1,5 @@
+pub mod proof_manager;
 pub mod proof_storage;
 
+pub use proof_manager::{ProofManager, ProofManagerConfig};
 pub use proof_storage::ProofStorage;

crates/apollo_proof_manager/src/proof_manager.rs

@@ -1 +1,45 @@
+use std::path::PathBuf;
 
+use starknet_api::transaction::fields::Proof;
+use starknet_types_core::felt::Felt;
+
+use crate::proof_storage::{FsProofStorage, FsProofStorageError, ProofStorage};
+
+/// Configuration for the proof manager.
+#[derive(Clone, Debug)]
+pub struct ProofManagerConfig {
+    pub persistent_root: PathBuf,
+}
+
+/// Proof manager that wraps filesystem-based proof storage.
+pub struct ProofManager {
+    pub proof_storage: FsProofStorage,
+}
+
+impl ProofManager {
+    pub fn new(config: ProofManagerConfig) -> Self {
+        let proof_storage =
+            FsProofStorage::new(config.persistent_root).expect("Failed to create proof storage.");
+        Self { proof_storage }
+    }
+}
+
+impl ProofStorage for ProofManager {
+    type Error = FsProofStorageError;
+
+    fn set_proof(&self, facts_hash: Felt, proof: Proof) -> Result<(), Self::Error> {
+        self.proof_storage.set_proof(facts_hash, proof)
+    }
+
+    fn get_proof(&self, facts_hash: Felt) -> Result<Option<Proof>, Self::Error> {
+        self.proof_storage.get_proof(facts_hash)
+    }
+
+    fn contains_proof(&self, facts_hash: Felt) -> Result<bool, Self::Error> {
+        self.proof_storage.contains_proof(facts_hash)
+    }
+}
+
+pub fn create_proof_manager(config: ProofManagerConfig) -> ProofManager {
+    ProofManager::new(config)
+}

crates/apollo_proof_manager/src/proof_storage.rs

@@ -46,20 +46,17 @@ impl FsProofStorage {
     /// a1/
     /// └── b2/
     ///     └── a1b2c3d4.../
-    #[allow(dead_code)]
     fn get_proof_dir(&self, facts_hash: Felt) -> PathBuf {
         let facts_hash = hex::encode(facts_hash.to_bytes_be());
         let (first_msb_byte, second_msb_byte, _rest_of_bytes) =
             (&facts_hash[..2], &facts_hash[2..4], &facts_hash[4..]);
         PathBuf::from(first_msb_byte).join(second_msb_byte).join(facts_hash)
     }
 
-    #[allow(dead_code)]
     fn get_persistent_dir(&self, facts_hash: Felt) -> PathBuf {
         self.persistent_root.join(self.get_proof_dir(facts_hash))
     }
 
-    #[allow(dead_code)]
     fn get_persistent_dir_with_create(&self, facts_hash: Felt) -> FsProofStorageResult<PathBuf> {
         let path = self.get_persistent_dir(facts_hash);
         if let Some(parent) = path.parent() {
@@ -69,7 +66,6 @@ impl FsProofStorage {
         Ok(path)
     }
 
-    #[allow(dead_code)]
     fn create_tmp_dir(
         &self,
         facts_hash: Felt,