apollo_proof_manager: calculate hash within the proof storage

Author: einat-starkware

crates/apollo_proof_manager/src/proof_manager.rs

@@ -1,6 +1,5 @@
 use apollo_proof_manager_config::config::ProofManagerConfig;
-use starknet_api::transaction::fields::Proof;
-use starknet_types_core::felt::Felt;
+use starknet_api::transaction::fields::{Proof, ProofFacts};
 
 use crate::proof_storage::{FsProofStorage, FsProofStorageError, ProofStorage};
 /// Proof manager that wraps filesystem-based proof storage.
@@ -20,15 +19,15 @@ impl ProofManager {
 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 set_proof(&self, proof_facts: ProofFacts, proof: Proof) -> Result<(), Self::Error> {
+        self.proof_storage.set_proof(proof_facts, proof)
     }
 
-    fn get_proof(&self, facts_hash: Felt) -> Result<Option<Proof>, Self::Error> {
-        self.proof_storage.get_proof(facts_hash)
+    fn get_proof(&self, proof_facts: ProofFacts) -> Result<Option<Proof>, Self::Error> {
+        self.proof_storage.get_proof(proof_facts)
     }
 
-    fn contains_proof(&self, facts_hash: Felt) -> Result<bool, Self::Error> {
-        self.proof_storage.contains_proof(facts_hash)
+    fn contains_proof(&self, proof_facts: ProofFacts) -> Result<bool, Self::Error> {
+        self.proof_storage.contains_proof(proof_facts)
     }
 }

crates/apollo_proof_manager/src/proof_storage.rs

@@ -5,7 +5,7 @@ use std::io::{BufWriter, Read, Write};
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
 
-use starknet_api::transaction::fields::Proof;
+use starknet_api::transaction::fields::{Proof, ProofFacts};
 use starknet_types_core::felt::Felt;
 use thiserror::Error;
 
@@ -15,9 +15,9 @@ mod proof_storage_test;
 
 pub trait ProofStorage: Send + Sync {
     type Error: Error;
-    fn set_proof(&self, facts_hash: Felt, proof: Proof) -> Result<(), Self::Error>;
-    fn get_proof(&self, facts_hash: Felt) -> Result<Option<Proof>, Self::Error>;
-    fn contains_proof(&self, facts_hash: Felt) -> Result<bool, Self::Error>;
+    fn set_proof(&self, proof_facts: ProofFacts, proof: Proof) -> Result<(), Self::Error>;
+    fn get_proof(&self, proof_facts: ProofFacts) -> Result<Option<Proof>, Self::Error>;
+    fn contains_proof(&self, proof_facts: ProofFacts) -> Result<bool, Self::Error>;
 }
 
 #[derive(Debug, Error)]
@@ -150,20 +150,27 @@ impl FsProofStorage {
         std::fs::rename(tmp_dir, persistent_dir)?;
         Ok(())
     }
+
+    fn contains_proof_by_hash(&self, facts_hash: Felt) -> bool {
+        self.get_persistent_dir(facts_hash).exists()
+    }
 }
 
 impl ProofStorage for FsProofStorage {
     type Error = FsProofStorageError;
 
-    fn set_proof(&self, facts_hash: Felt, proof: Proof) -> Result<(), Self::Error> {
-        if self.contains_proof(facts_hash)? {
+    fn set_proof(&self, proof_facts: ProofFacts, proof: Proof) -> Result<(), Self::Error> {
+        let facts_hash = proof_facts.hash();
+
+        if self.contains_proof_by_hash(facts_hash) {
             return Ok(());
         }
         self.write_proof_atomically(facts_hash, proof)
     }
 
-    fn get_proof(&self, facts_hash: Felt) -> Result<Option<Proof>, Self::Error> {
-        if !self.contains_proof(facts_hash)? {
+    fn get_proof(&self, proof_facts: ProofFacts) -> Result<Option<Proof>, Self::Error> {
+        let facts_hash = proof_facts.hash();
+        if !self.contains_proof_by_hash(facts_hash) {
             return Ok(None);
         }
 
@@ -176,7 +183,7 @@ impl ProofStorage for FsProofStorage {
         }
     }
 
-    fn contains_proof(&self, facts_hash: Felt) -> Result<bool, Self::Error> {
-        Ok(self.get_persistent_dir(facts_hash).exists())
+    fn contains_proof(&self, proof_facts: ProofFacts) -> Result<bool, Self::Error> {
+        Ok(self.contains_proof_by_hash(proof_facts.hash()))
     }
 }

crates/apollo_proof_manager/src/proof_storage_test.rs

@@ -1,6 +1,6 @@
 use std::path::PathBuf;
 
-use starknet_api::transaction::fields::Proof;
+use starknet_api::transaction::fields::{Proof, ProofFacts};
 use starknet_types_core::felt::Felt;
 
 use crate::proof_storage::{FsProofStorage, ProofStorage};
@@ -11,8 +11,8 @@ fn new_fs_proof_storage() -> FsProofStorage {
     FsProofStorage::new(persistent_root).expect("Failed to create FsProofStorage")
 }
 
-fn sample_facts_hash() -> Felt {
-    Felt::from(0x1234_u64)
+fn sample_proof_facts() -> ProofFacts {
+    ProofFacts::from(vec![Felt::from(0x1234_u64), Felt::from(0x5678_u64)])
 }
 
 fn sample_proof() -> Proof {
@@ -22,21 +22,20 @@ fn sample_proof() -> Proof {
 #[test]
 fn fs_proof_storage_get_before_set_returns_none() {
     let storage = new_fs_proof_storage();
-    let facts_hash = sample_facts_hash();
+    let proof_facts = sample_proof_facts();
 
-    let res = storage.get_proof(facts_hash);
+    let res = storage.get_proof(proof_facts);
     assert!(res.is_ok());
     assert!(res.unwrap().is_none());
 }
 
 #[test]
 fn fs_proof_storage_roundtrip() {
     let storage = new_fs_proof_storage();
-    let facts_hash = sample_facts_hash();
     let proof = sample_proof();
 
-    storage.set_proof(facts_hash, proof.clone()).unwrap();
+    storage.set_proof(sample_proof_facts(), proof.clone()).unwrap();
 
-    let retrieved = storage.get_proof(sample_facts_hash()).unwrap();
+    let retrieved = storage.get_proof(sample_proof_facts()).unwrap();
     assert_eq!(retrieved, Some(proof));
 }