apollo_proof_manager: create proof manager

Author: einat-starkware

Cargo.lock

@@ -12,11 +12,14 @@ testing = []
 workspace = true
 
 [dependencies]
+apollo_config.workspace = true
 hex.workspace = true
+serde = { workspace = true, features = ["derive"] }
 starknet-types-core = { workspace = true, features = ["hash"] }
 starknet_api.workspace = true
 tempfile.workspace = true
 thiserror.workspace = true
+validator.workspace = true
 
 
 [dev-dependencies]

crates/apollo_proof_manager/Cargo.toml

@@ -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/lib.rs

@@ -1 +1,61 @@
+use std::collections::BTreeMap;
+use std::path::PathBuf;
 
+use apollo_config::dumping::{ser_param, SerializeConfig};
+use apollo_config::{ParamPath, ParamPrivacyInput, SerializedParam};
+use serde::{Deserialize, Serialize};
+use starknet_api::transaction::fields::Proof;
+use starknet_types_core::felt::Felt;
+use validator::Validate;
+
+use crate::proof_storage::{FsProofStorage, FsProofStorageError, ProofStorage};
+
+/// Configuration for the proof manager.
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Validate)]
+pub struct ProofManagerConfig {
+    pub persistent_root: PathBuf,
+}
+impl Default for ProofManagerConfig {
+    fn default() -> Self {
+        Self { persistent_root: "/data/proofs".into() }
+    }
+}
+impl SerializeConfig for ProofManagerConfig {
+    fn dump(&self) -> BTreeMap<ParamPath, SerializedParam> {
+        BTreeMap::from([ser_param(
+            "persistent_root",
+            &self.persistent_root,
+            "Persistent root for proof storage.",
+            ParamPrivacyInput::Public,
+        )])
+    }
+}
+/// Proof manager that wraps filesystem-based proof storage.
+pub struct ProofManager {
+    pub proof_storage: FsProofStorage,
+    // TODO(Einat): Add cache.
+}
+
+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)
+    }
+}

crates/apollo_proof_manager/src/proof_manager.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,