refactor!: remove timestamp check from manager

Signed-off-by: Gustavo Inacio <gustavo@semiotic.ai>

tap_core/src/adapters/mock/executor_mock.rs

@@ -5,6 +5,7 @@ use crate::adapters::escrow_adapter::EscrowAdapter;
 use crate::adapters::receipt_storage_adapter::{
     safe_truncate_receipts, ReceiptRead, ReceiptStore, StoredReceipt,
 };
+use crate::checks::TimestampCheck;
 use crate::tap_receipt::ReceivedReceipt;
 use crate::{
     adapters::rav_storage_adapter::{RAVRead, RAVStore},
@@ -13,8 +14,8 @@ use crate::{
 use alloy_primitives::Address;
 use async_trait::async_trait;
 use std::ops::RangeBounds;
+use std::sync::RwLock;
 use std::{collections::HashMap, sync::Arc};
-use tokio::sync::RwLock;
 
 pub type EscrowStorage = Arc<RwLock<HashMap<Address, u128>>>;
 pub type QueryAppraisals = Arc<RwLock<HashMap<u64, u128>>>;
@@ -37,27 +38,31 @@ pub struct ExecutorMock {
     unique_id: Arc<RwLock<u64>>,
 
     sender_escrow_storage: EscrowStorage,
+
+    timestamp_check: Arc<TimestampCheck>,
 }
 
 impl ExecutorMock {
     pub fn new(
         rav_storage: RAVStorage,
         receipt_storage: ReceiptStorage,
         sender_escrow_storage: EscrowStorage,
+        timestamp_check: Arc<TimestampCheck>,
     ) -> Self {
         ExecutorMock {
             rav_storage,
             receipt_storage,
             unique_id: Arc::new(RwLock::new(0)),
             sender_escrow_storage,
+            timestamp_check,
         }
     }
 
     pub async fn retrieve_receipt_by_id(
         &self,
         receipt_id: u64,
     ) -> Result<ReceivedReceipt, AdapterErrorMock> {
-        let receipt_storage = self.receipt_storage.read().await;
+        let receipt_storage = self.receipt_storage.read().unwrap();
 
         receipt_storage
             .get(&receipt_id)
@@ -71,7 +76,7 @@ impl ExecutorMock {
         &self,
         timestamp_ns: u64,
     ) -> Result<Vec<(u64, ReceivedReceipt)>, AdapterErrorMock> {
-        let receipt_storage = self.receipt_storage.read().await;
+        let receipt_storage = self.receipt_storage.read().unwrap();
         Ok(receipt_storage
             .iter()
             .filter(|(_, rx_receipt)| {
@@ -90,7 +95,7 @@ impl ExecutorMock {
     }
 
     pub async fn remove_receipt_by_id(&mut self, receipt_id: u64) -> Result<(), AdapterErrorMock> {
-        let mut receipt_storage = self.receipt_storage.write().await;
+        let mut receipt_storage = self.receipt_storage.write().unwrap();
         receipt_storage
             .remove(&receipt_id)
             .map(|_| ())
@@ -114,8 +119,10 @@ impl RAVStore for ExecutorMock {
     type AdapterError = AdapterErrorMock;
 
     async fn update_last_rav(&self, rav: SignedRAV) -> Result<(), Self::AdapterError> {
-        let mut rav_storage = self.rav_storage.write().await;
+        let mut rav_storage = self.rav_storage.write().unwrap();
+        let timestamp = rav.message.timestampNs;
         *rav_storage = Some(rav);
+        self.timestamp_check.update_min_timestamp_ns(timestamp);
         Ok(())
     }
 }
@@ -125,17 +132,17 @@ impl RAVRead for ExecutorMock {
     type AdapterError = AdapterErrorMock;
 
     async fn last_rav(&self) -> Result<Option<SignedRAV>, Self::AdapterError> {
-        Ok(self.rav_storage.read().await.clone())
+        Ok(self.rav_storage.read().unwrap().clone())
     }
 }
 
 #[async_trait]
 impl ReceiptStore for ExecutorMock {
     type AdapterError = AdapterErrorMock;
     async fn store_receipt(&self, receipt: ReceivedReceipt) -> Result<u64, Self::AdapterError> {
-        let mut id_pointer = self.unique_id.write().await;
+        let mut id_pointer = self.unique_id.write().unwrap();
         let id_previous = *id_pointer;
-        let mut receipt_storage = self.receipt_storage.write().await;
+        let mut receipt_storage = self.receipt_storage.write().unwrap();
         receipt_storage.insert(*id_pointer, receipt);
         *id_pointer += 1;
         Ok(id_previous)
@@ -145,7 +152,7 @@ impl ReceiptStore for ExecutorMock {
         receipt_id: u64,
         receipt: ReceivedReceipt,
     ) -> Result<(), Self::AdapterError> {
-        let mut receipt_storage = self.receipt_storage.write().await;
+        let mut receipt_storage = self.receipt_storage.write().unwrap();
 
         if !receipt_storage.contains_key(&receipt_id) {
             return Err(AdapterErrorMock::AdapterError {
@@ -154,14 +161,14 @@ impl ReceiptStore for ExecutorMock {
         };
 
         receipt_storage.insert(receipt_id, receipt);
-        *self.unique_id.write().await += 1;
+        *self.unique_id.write().unwrap() += 1;
         Ok(())
     }
     async fn remove_receipts_in_timestamp_range<R: RangeBounds<u64> + std::marker::Send>(
         &self,
         timestamp_ns: R,
     ) -> Result<(), Self::AdapterError> {
-        let mut receipt_storage = self.receipt_storage.write().await;
+        let mut receipt_storage = self.receipt_storage.write().unwrap();
         receipt_storage.retain(|_, rx_receipt| {
             !timestamp_ns.contains(&rx_receipt.signed_receipt().message.timestamp_ns)
         });
@@ -177,7 +184,7 @@ impl ReceiptRead for ExecutorMock {
         timestamp_range_ns: R,
         limit: Option<u64>,
     ) -> Result<Vec<StoredReceipt>, Self::AdapterError> {
-        let receipt_storage = self.receipt_storage.read().await;
+        let receipt_storage = self.receipt_storage.read().unwrap();
         let mut receipts_in_range: Vec<(u64, ReceivedReceipt)> = receipt_storage
             .iter()
             .filter(|(_, rx_receipt)| {
@@ -194,8 +201,8 @@ impl ReceiptRead for ExecutorMock {
 }
 
 impl ExecutorMock {
-    pub async fn escrow(&self, sender_id: Address) -> Result<u128, AdapterErrorMock> {
-        let sender_escrow_storage = self.sender_escrow_storage.read().await;
+    pub fn escrow(&self, sender_id: Address) -> Result<u128, AdapterErrorMock> {
+        let sender_escrow_storage = self.sender_escrow_storage.read().unwrap();
         if let Some(escrow) = sender_escrow_storage.get(&sender_id) {
             return Ok(*escrow);
         }
@@ -204,23 +211,19 @@ impl ExecutorMock {
         })
     }
 
-    pub async fn increase_escrow(&mut self, sender_id: Address, value: u128) {
-        let mut sender_escrow_storage = self.sender_escrow_storage.write().await;
+    pub fn increase_escrow(&mut self, sender_id: Address, value: u128) {
+        let mut sender_escrow_storage = self.sender_escrow_storage.write().unwrap();
 
         if let Some(current_value) = sender_escrow_storage.get(&sender_id) {
-            let mut sender_escrow_storage = self.sender_escrow_storage.write().await;
+            let mut sender_escrow_storage = self.sender_escrow_storage.write().unwrap();
             sender_escrow_storage.insert(sender_id, current_value + value);
         } else {
             sender_escrow_storage.insert(sender_id, value);
         }
     }
 
-    pub async fn reduce_escrow(
-        &self,
-        sender_id: Address,
-        value: u128,
-    ) -> Result<(), AdapterErrorMock> {
-        let mut sender_escrow_storage = self.sender_escrow_storage.write().await;
+    pub fn reduce_escrow(&self, sender_id: Address, value: u128) -> Result<(), AdapterErrorMock> {
+        let mut sender_escrow_storage = self.sender_escrow_storage.write().unwrap();
 
         if let Some(current_value) = sender_escrow_storage.get(&sender_id) {
             let checked_new_value = current_value.checked_sub(value);
@@ -239,13 +242,13 @@ impl ExecutorMock {
 impl EscrowAdapter for ExecutorMock {
     type AdapterError = AdapterErrorMock;
     async fn get_available_escrow(&self, sender_id: Address) -> Result<u128, Self::AdapterError> {
-        self.escrow(sender_id).await
+        self.escrow(sender_id)
     }
     async fn subtract_escrow(
         &self,
         sender_id: Address,
         value: u128,
     ) -> Result<(), Self::AdapterError> {
-        self.reduce_escrow(sender_id, value).await
+        self.reduce_escrow(sender_id, value)
     }
 }

tap_core/src/adapters/test/escrow_adapter_test.rs

@@ -3,24 +3,37 @@
 
 #[cfg(test)]
 mod escrow_adapter_unit_test {
-    use std::{collections::HashMap, sync::Arc};
+    use std::{
+        collections::HashMap,
+        sync::{Arc, RwLock},
+    };
 
     use ethers::signers::{coins_bip39::English, LocalWallet, MnemonicBuilder, Signer};
     use rstest::*;
-    use tokio::sync::RwLock;
 
-    use crate::adapters::{escrow_adapter::EscrowAdapter, executor_mock::ExecutorMock};
+    use crate::{
+        adapters::{escrow_adapter::EscrowAdapter, executor_mock::ExecutorMock},
+        checks::TimestampCheck,
+    };
 
-    #[rstest]
-    #[tokio::test]
-    async fn escrow_adapter_test() {
+    #[fixture]
+    fn executor() -> ExecutorMock {
+        let escrow_storage = Arc::new(RwLock::new(HashMap::new()));
         let rav_storage = Arc::new(RwLock::new(None));
         let receipt_storage = Arc::new(RwLock::new(HashMap::new()));
-        let sender_escrow_storage = Arc::new(RwLock::new(HashMap::new()));
 
-        let mut escrow_adapter =
-            ExecutorMock::new(rav_storage, receipt_storage, sender_escrow_storage.clone());
+        let timestamp_check = Arc::new(TimestampCheck::new(0));
+        ExecutorMock::new(
+            rav_storage,
+            receipt_storage.clone(),
+            escrow_storage.clone(),
+            timestamp_check,
+        )
+    }
 
+    #[rstest]
+    #[tokio::test]
+    async fn escrow_adapter_test(mut executor: ExecutorMock) {
         let wallet: LocalWallet = MnemonicBuilder::<English>::default()
          .phrase("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about")
          .build()
@@ -39,42 +52,31 @@ mod escrow_adapter_unit_test {
 
         let initial_value = 500u128;
 
-        escrow_adapter
-            .increase_escrow(sender_id, initial_value)
-            .await;
+        executor.increase_escrow(sender_id, initial_value);
 
         // Check that sender exists and has valid value through adapter
-        assert!(escrow_adapter.get_available_escrow(sender_id).await.is_ok());
+        assert!(executor.get_available_escrow(sender_id).await.is_ok());
         assert_eq!(
-            escrow_adapter
-                .get_available_escrow(sender_id)
-                .await
-                .unwrap(),
+            executor.get_available_escrow(sender_id).await.unwrap(),
             initial_value
         );
 
         // Check that subtracting is valid for valid sender, and results in expected value
-        assert!(escrow_adapter
+        assert!(executor
             .subtract_escrow(sender_id, initial_value)
             .await
             .is_ok());
-        assert!(escrow_adapter.get_available_escrow(sender_id).await.is_ok());
-        assert_eq!(
-            escrow_adapter
-                .get_available_escrow(sender_id)
-                .await
-                .unwrap(),
-            0
-        );
+        assert!(executor.get_available_escrow(sender_id).await.is_ok());
+        assert_eq!(executor.get_available_escrow(sender_id).await.unwrap(), 0);
 
         // Check that subtracting to negative escrow results in err
-        assert!(escrow_adapter
+        assert!(executor
             .subtract_escrow(sender_id, initial_value)
             .await
             .is_err());
 
         // Check that accessing non initialized sender results in err
-        assert!(escrow_adapter
+        assert!(executor
             .get_available_escrow(invalid_sender_id)
             .await
             .is_err());

tap_core/src/adapters/test/rav_storage_adapter_test.rs

@@ -4,15 +4,16 @@
 #[cfg(test)]
 mod rav_storage_adapter_unit_test {
     use std::collections::HashMap;
+    use std::sync::RwLock;
     use std::{str::FromStr, sync::Arc};
 
     use alloy_primitives::Address;
     use alloy_sol_types::Eip712Domain;
     use ethers::signers::coins_bip39::English;
     use ethers::signers::{LocalWallet, MnemonicBuilder};
     use rstest::*;
-    use tokio::sync::RwLock;
 
+    use crate::checks::TimestampCheck;
     use crate::{
         adapters::{
             executor_mock::ExecutorMock,
@@ -29,16 +30,24 @@ mod rav_storage_adapter_unit_test {
         tap_eip712_domain(1, Address::from([0x11u8; 20]))
     }
 
-    #[rstest]
-    #[tokio::test]
-    async fn rav_storage_adapter_test(domain_separator: Eip712Domain) {
+    #[fixture]
+    fn executor() -> ExecutorMock {
+        let escrow_storage = Arc::new(RwLock::new(HashMap::new()));
         let rav_storage = Arc::new(RwLock::new(None));
         let receipt_storage = Arc::new(RwLock::new(HashMap::new()));
-        let sender_escrow_storage = Arc::new(RwLock::new(HashMap::new()));
 
-        let rav_storage_adapter =
-            ExecutorMock::new(rav_storage, receipt_storage, sender_escrow_storage.clone());
+        let timestamp_check = Arc::new(TimestampCheck::new(0));
+        ExecutorMock::new(
+            rav_storage,
+            receipt_storage.clone(),
+            escrow_storage.clone(),
+            timestamp_check,
+        )
+    }
 
+    #[rstest]
+    #[tokio::test]
+    async fn rav_storage_adapter_test(domain_separator: Eip712Domain, executor: ExecutorMock) {
         let wallet: LocalWallet = MnemonicBuilder::<English>::default()
          .phrase("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about")
          .build()
@@ -70,13 +79,10 @@ mod rav_storage_adapter_unit_test {
         )
         .unwrap();
 
-        rav_storage_adapter
-            .update_last_rav(signed_rav.clone())
-            .await
-            .unwrap();
+        executor.update_last_rav(signed_rav.clone()).await.unwrap();
 
         // Retreive rav
-        let retrieved_rav = rav_storage_adapter.last_rav().await;
+        let retrieved_rav = executor.last_rav().await;
         assert!(retrieved_rav.unwrap().unwrap() == signed_rav);
 
         // Testing the last rav update...
@@ -102,13 +108,10 @@ mod rav_storage_adapter_unit_test {
         .unwrap();
 
         // Update the last rav
-        rav_storage_adapter
-            .update_last_rav(signed_rav.clone())
-            .await
-            .unwrap();
+        executor.update_last_rav(signed_rav.clone()).await.unwrap();
 
         // Retreive rav
-        let retrieved_rav = rav_storage_adapter.last_rav().await;
+        let retrieved_rav = executor.last_rav().await;
         assert!(retrieved_rav.unwrap().unwrap() == signed_rav);
     }
 }