revert: rename back to adapters

Signed-off-by: Gustavo Inacio <[email protected]>

Author: gusinacio

tap_core/src/error.rs

@@ -36,8 +36,8 @@ pub enum Error {
         received_rav: ReceiptAggregateVoucher,
         expected_rav: ReceiptAggregateVoucher,
     },
-    #[error("Error from strategy.\n Caused by: {source_error}")]
-    StrategyError { source_error: anyhow::Error },
+    #[error("Error from adapter.\n Caused by: {source_error}")]
+    AdapterError { source_error: anyhow::Error },
     #[error("Failed to produce rav request, no valid receipts")]
     NoValidReceiptsForRAVRequest,
     #[error("Previous RAV allocation id ({prev_id}) doesn't match the allocation id from the new receipt ({new_id}).")]

tap_core/src/manager/strategy/escrow.rs renamed to tap_core/src/manager/adapters/escrow.rs

@@ -15,18 +15,18 @@ use crate::{
 ///
 /// This trait is designed to be implemented by users of this library who want to
 /// customize the management of local accounting for available escrow. The error handling is also
-/// customizable by defining an `StrategyError` type, which must implement both `Error`
+/// customizable by defining an `AdapterError` type, which must implement both `Error`
 /// and `Debug` from the standard library.
 ///
 /// # Usage
 ///
 /// The `get_available_escrow` method should be used to retrieve the local accounting
 ///  amount of available escrow for a specified sender. Any errors during this operation
-/// should be captured and returned in the `StrategyError` format.
+/// should be captured and returned in the `AdapterError` format.
 ///
 /// The `subtract_escrow` method is used to deduct a specified value from the local accounting
 /// of available escrow of a specified sender. Any errors during this operation should be captured
-/// and returned as an `StrategyError`.
+/// and returned as an `AdapterError`.
 ///
 /// This trait is utilized by [crate::tap_manager], which relies on these
 /// operations for managing escrow.
@@ -41,27 +41,27 @@ pub trait EscrowHandler: Send + Sync {
     ///
     /// This error type should implement the `Error` and `Debug` traits from the standard library.
     /// Errors of this type are returned to the user when an operation fails.
-    type StrategyError: std::error::Error + std::fmt::Debug + Send + Sync + 'static;
+    type AdapterError: std::error::Error + std::fmt::Debug + Send + Sync + 'static;
 
     /// Retrieves the local accounting amount of available escrow for a specified sender.
     ///
     /// This method should be implemented to fetch the local accounting amount of available escrow for a
     /// specified sender from your system. Any errors that occur during this process should
-    /// be captured and returned as an `StrategyError`.
-    async fn get_available_escrow(&self, sender_id: Address) -> Result<u128, Self::StrategyError>;
+    /// be captured and returned as an `AdapterError`.
+    async fn get_available_escrow(&self, sender_id: Address) -> Result<u128, Self::AdapterError>;
 
     /// Deducts a specified value from the local accounting of available escrow for a specified sender.
     ///
     /// This method should be implemented to deduct a specified value from the local accounting of
     /// available escrow of a specified sender in your system. Any errors that occur during this
-    /// process should be captured and returned as an `StrategyError`.
+    /// process should be captured and returned as an `AdapterError`.
     async fn subtract_escrow(
         &self,
         sender_id: Address,
         value: u128,
-    ) -> Result<(), Self::StrategyError>;
+    ) -> Result<(), Self::AdapterError>;
 
-    async fn verify_signer(&self, signer_address: Address) -> Result<bool, Self::StrategyError>;
+    async fn verify_signer(&self, signer_address: Address) -> Result<bool, Self::AdapterError>;
 
     async fn check_and_reserve_escrow(
         &self,

tap_core/src/manager/strategy/mod.rs renamed to tap_core/src/manager/adapters/mod.rs

@@ -9,14 +9,14 @@ use crate::rav::SignedRAV;
 ///
 /// This trait is designed to be implemented by users of this library who want to
 /// customize the write storage behavior of `SignedRAV` data. The error handling is also
-/// customizable by defining an `StrategyError` type, which must implement both `Error`
+/// customizable by defining an `AdapterError` type, which must implement both `Error`
 /// and `Debug` from the standard library.
 ///
 /// # Usage
 ///
 /// The `update_last_rav` method should be used to update the last validated `SignedRAV`
 /// in the storage managed by the adapter. Errors during this operation should be
-/// captured and returned in the `StrategyError` format.
+/// captured and returned in the `AdapterError` format.
 ///
 /// This trait is utilized by [crate::tap_manager], which relies on these
 /// operations for working with `SignedRAV` data.
@@ -31,27 +31,27 @@ pub trait RAVStore {
     ///
     /// This error type should implement the `Error` and `Debug` traits from the standard library.
     /// Errors of this type are returned to the user when an operation fails.
-    type StrategyError: std::error::Error + std::fmt::Debug + Send + Sync + 'static;
+    type AdapterError: std::error::Error + std::fmt::Debug + Send + Sync + 'static;
 
     /// Updates the storage with the latest validated `SignedRAV`.
     ///
     /// This method should be implemented to store the most recent validated `SignedRAV` into your chosen storage system.
-    /// Any errors that occur during this process should be captured and returned as an `StrategyError`.
-    async fn update_last_rav(&self, rav: SignedRAV) -> Result<(), Self::StrategyError>;
+    /// Any errors that occur during this process should be captured and returned as an `AdapterError`.
+    async fn update_last_rav(&self, rav: SignedRAV) -> Result<(), Self::AdapterError>;
 }
 
 /// `RAVRead` defines a trait for read storage adapters to handle `SignedRAV` data.
 ///
 /// This trait is designed to be implemented by users of this library who want to
 /// customize the read storage behavior of `SignedRAV` data. The error handling is also
-/// customizable by defining an `StrategyError` type, which must implement both `Error`
+/// customizable by defining an `AdapterError` type, which must implement both `Error`
 /// and `Debug` from the standard library.
 ///
 /// # Usage
 ///
 /// The `last_rav` method is designed to fetch the latest `SignedRAV` from the storage.
 /// If there is no `SignedRAV` available, it should return `None`. Any errors during
-/// this operation should be captured and returned as an `StrategyError`.
+/// this operation should be captured and returned as an `AdapterError`.
 ///
 /// This trait is utilized by [crate::tap_manager], which relies on these
 /// operations for working with `SignedRAV` data.
@@ -66,12 +66,12 @@ pub trait RAVRead {
     ///
     /// This error type should implement the `Error` and `Debug` traits from the standard library.
     /// Errors of this type are returned to the user when an operation fails.
-    type StrategyError: std::error::Error + std::fmt::Debug + Send + Sync + 'static;
+    type AdapterError: std::error::Error + std::fmt::Debug + Send + Sync + 'static;
 
     /// Retrieves the latest `SignedRAV` from the storage.
     ///
     /// This method should be implemented to fetch the latest `SignedRAV` from your storage system.
     /// If no `SignedRAV` is available, this method should return `None`.
-    /// Any errors that occur during this process should be captured and returned as an `StrategyError`.
-    async fn last_rav(&self) -> Result<Option<SignedRAV>, Self::StrategyError>;
+    /// Any errors that occur during this process should be captured and returned as an `AdapterError`.
+    async fn last_rav(&self) -> Result<Option<SignedRAV>, Self::AdapterError>;
 }

tap_core/src/manager/strategy/rav.rs renamed to tap_core/src/manager/adapters/rav.rs

@@ -11,20 +11,20 @@ use crate::receipt::{Checking, ReceiptState, ReceiptWithState};
 ///
 /// This trait is designed to be implemented by users of this library who want to
 /// customize the write storage behavior of `ReceivedReceipt` data. The error handling is also
-/// customizable by defining an `StrategyError` type, which must implement both `Error`
+/// customizable by defining an `AdapterError` type, which must implement both `Error`
 /// and `Debug` from the standard library.
 ///
 /// # Usage
 ///
 /// The `store_receipt` method should be used to store a new `ReceivedReceipt` in the storage
 /// managed by the adapter. It returns a unique receipt_id associated with the stored receipt.
-/// Any errors during this operation should be captured and returned in the `StrategyError` format.
+/// Any errors during this operation should be captured and returned in the `AdapterError` format.
 ///
 /// The `update_receipt_by_id` method is designed to update a specific `ReceivedReceipt` identified by a unique
-/// receipt_id. Any errors during this operation should be captured and returned as an `StrategyError`.
+/// receipt_id. Any errors during this operation should be captured and returned as an `AdapterError`.
 ///
 /// The `remove_receipts_in_timestamp_range` method is used to remove all `ReceivedReceipts` within a specific
-/// timestamp range from the storage. Any errors during this operation should be captured and returned as an `StrategyError`.
+/// timestamp range from the storage. Any errors during this operation should be captured and returned as an `AdapterError`.
 ///
 /// This trait is utilized by [crate::tap_manager], which relies on these
 /// operations for working with `ReceivedReceipt` data.
@@ -39,17 +39,17 @@ pub trait ReceiptStore {
     ///
     /// This error type should implement the `Error` and `Debug` traits from the standard library.
     /// Errors of this type are returned to the user when an operation fails.
-    type StrategyError: std::error::Error + std::fmt::Debug + Send + Sync + 'static;
+    type AdapterError: std::error::Error + std::fmt::Debug + Send + Sync + 'static;
 
     /// Stores a new `ReceivedReceipt` into the storage.
     ///
     /// This method should be implemented to store a new `ReceivedReceipt` into your chosen storage system.
     /// It returns a unique receipt_id associated with the stored receipt. Any errors that occur during
-    /// this process should be captured and returned as an `StrategyError`.
+    /// this process should be captured and returned as an `AdapterError`.
     async fn store_receipt(
         &self,
         receipt: ReceiptWithState<Checking>,
-    ) -> Result<u64, Self::StrategyError>;
+    ) -> Result<u64, Self::AdapterError>;
 }
 
 #[async_trait]
@@ -58,23 +58,23 @@ pub trait ReceiptDelete {
     ///
     /// This error type should implement the `Error` and `Debug` traits from the standard library.
     /// Errors of this type are returned to the user when an operation fails.
-    type StrategyError: std::error::Error + std::fmt::Debug + Send + Sync + 'static;
+    type AdapterError: std::error::Error + std::fmt::Debug + Send + Sync + 'static;
     /// Removes all `ReceivedReceipts` within a specific timestamp range from the storage.
     ///
     /// This method should be implemented to remove all `ReceivedReceipts` within a specific timestamp
     /// range from your storage system. Any errors that occur during this process should be captured and
-    /// returned as an `StrategyError`.
+    /// returned as an `AdapterError`.
     async fn remove_receipts_in_timestamp_range<R: RangeBounds<u64> + std::marker::Send>(
         &self,
         timestamp_ns: R,
-    ) -> Result<(), Self::StrategyError>;
+    ) -> Result<(), Self::AdapterError>;
 }
 
 /// `ReceiptRead` defines a trait for read storage adapters to manage `ReceivedReceipt` data.
 ///
 /// This trait is designed to be implemented by users of this library who want to
 /// customize the read storage behavior of `ReceivedReceipt` data. The error handling is also
-/// customizable by defining an `StrategyError` type, which must implement both `Error`
+/// customizable by defining an `AdapterError` type, which must implement both `Error`
 /// and `Debug` from the standard library.
 ///
 /// # Usage
@@ -88,7 +88,7 @@ pub trait ReceiptRead {
     ///
     /// This error type should implement the `Error` and `Debug` traits from the standard library.
     /// Errors of this type are returned to the user when an operation fails.
-    type StrategyError: std::error::Error + std::fmt::Debug + Send + Sync + 'static;
+    type AdapterError: std::error::Error + std::fmt::Debug + Send + Sync + 'static;
 
     /// Retrieves all `ReceivedReceipts` within a specific timestamp range.
     ///
@@ -110,12 +110,12 @@ pub trait ReceiptRead {
     /// You can use the [`safe_truncate_receipts()`] function to help with this, but feel free to
     /// implement a more efficient solution for your situation if you can.
     ///
-    /// Any errors that occur during this process should be captured and returned as an `StrategyError`.
+    /// Any errors that occur during this process should be captured and returned as an `AdapterError`.
     async fn retrieve_receipts_in_timestamp_range<R: RangeBounds<u64> + std::marker::Send>(
         &self,
         timestamp_range_ns: R,
         limit: Option<u64>,
-    ) -> Result<Vec<ReceiptWithState<Checking>>, Self::StrategyError>;
+    ) -> Result<Vec<ReceiptWithState<Checking>>, Self::AdapterError>;
 }
 
 /// See [`ReceiptStorageAdapter::retrieve_receipts_in_timestamp_range()`] for details.

tap_core/src/manager/strategy/receipt.rs renamed to tap_core/src/manager/adapters/receipt.rs

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::{
-    manager::strategy::*,
+    manager::adapters::*,
     rav::SignedRAV,
     receipt::{checks::TimestampCheck, Checking, ReceiptWithState},
     signed_message::MessageId,
@@ -23,7 +23,7 @@ use thiserror::Error;
 #[derive(Debug, Error)]
 pub enum InMemoryError {
     #[error("something went wrong: {error}")]
-    StrategyError { error: String },
+    AdapterError { error: String },
 }
 
 #[derive(Clone)]
@@ -68,7 +68,7 @@ impl InMemoryContext {
         receipt_storage
             .get(&receipt_id)
             .cloned()
-            .ok_or(InMemoryError::StrategyError {
+            .ok_or(InMemoryError::AdapterError {
                 error: "No receipt found with ID".to_owned(),
             })
     }
@@ -100,7 +100,7 @@ impl InMemoryContext {
         receipt_storage
             .remove(&receipt_id)
             .map(|_| ())
-            .ok_or(InMemoryError::StrategyError {
+            .ok_or(InMemoryError::AdapterError {
                 error: "No receipt found with ID".to_owned(),
             })
     }
@@ -117,9 +117,9 @@ impl InMemoryContext {
 
 #[async_trait]
 impl RAVStore for InMemoryContext {
-    type StrategyError = InMemoryError;
+    type AdapterError = InMemoryError;
 
-    async fn update_last_rav(&self, rav: SignedRAV) -> Result<(), Self::StrategyError> {
+    async fn update_last_rav(&self, rav: SignedRAV) -> Result<(), Self::AdapterError> {
         let mut rav_storage = self.rav_storage.write().unwrap();
         let timestamp = rav.message.timestampNs;
         *rav_storage = Some(rav);
@@ -130,21 +130,21 @@ impl RAVStore for InMemoryContext {
 
 #[async_trait]
 impl RAVRead for InMemoryContext {
-    type StrategyError = InMemoryError;
+    type AdapterError = InMemoryError;
 
-    async fn last_rav(&self) -> Result<Option<SignedRAV>, Self::StrategyError> {
+    async fn last_rav(&self) -> Result<Option<SignedRAV>, Self::AdapterError> {
         Ok(self.rav_storage.read().unwrap().clone())
     }
 }
 
 #[async_trait]
 impl ReceiptStore for InMemoryContext {
-    type StrategyError = InMemoryError;
+    type AdapterError = InMemoryError;
 
     async fn store_receipt(
         &self,
         receipt: ReceiptWithState<Checking>,
-    ) -> Result<u64, Self::StrategyError> {
+    ) -> Result<u64, Self::AdapterError> {
         let mut id_pointer = self.unique_id.write().unwrap();
         let id_previous = *id_pointer;
         let mut receipt_storage = self.receipt_storage.write().unwrap();
@@ -156,12 +156,12 @@ impl ReceiptStore for InMemoryContext {
 
 #[async_trait]
 impl ReceiptDelete for InMemoryContext {
-    type StrategyError = InMemoryError;
+    type AdapterError = InMemoryError;
 
     async fn remove_receipts_in_timestamp_range<R: RangeBounds<u64> + std::marker::Send>(
         &self,
         timestamp_ns: R,
-    ) -> Result<(), Self::StrategyError> {
+    ) -> Result<(), Self::AdapterError> {
         let mut receipt_storage = self.receipt_storage.write().unwrap();
         receipt_storage.retain(|_, rx_receipt| {
             !timestamp_ns.contains(&rx_receipt.signed_receipt().message.timestamp_ns)
@@ -171,12 +171,12 @@ impl ReceiptDelete for InMemoryContext {
 }
 #[async_trait]
 impl ReceiptRead for InMemoryContext {
-    type StrategyError = InMemoryError;
+    type AdapterError = InMemoryError;
     async fn retrieve_receipts_in_timestamp_range<R: RangeBounds<u64> + std::marker::Send>(
         &self,
         timestamp_range_ns: R,
         limit: Option<u64>,
-    ) -> Result<Vec<ReceiptWithState<Checking>>, Self::StrategyError> {
+    ) -> Result<Vec<ReceiptWithState<Checking>>, Self::AdapterError> {
         let receipt_storage = self.receipt_storage.read().unwrap();
         let mut receipts_in_range: Vec<ReceiptWithState<Checking>> = receipt_storage
             .iter()
@@ -199,7 +199,7 @@ impl InMemoryContext {
         if let Some(escrow) = sender_escrow_storage.get(&sender_id) {
             return Ok(*escrow);
         }
-        Err(InMemoryError::StrategyError {
+        Err(InMemoryError::AdapterError {
             error: "No escrow exists for provided sender ID.".to_owned(),
         })
     }
@@ -225,27 +225,27 @@ impl InMemoryContext {
                 return Ok(());
             }
         }
-        Err(InMemoryError::StrategyError {
+        Err(InMemoryError::AdapterError {
             error: "Provided value is greater than existing escrow.".to_owned(),
         })
     }
 }
 
 #[async_trait]
 impl EscrowHandler for InMemoryContext {
-    type StrategyError = InMemoryError;
-    async fn get_available_escrow(&self, sender_id: Address) -> Result<u128, Self::StrategyError> {
+    type AdapterError = InMemoryError;
+    async fn get_available_escrow(&self, sender_id: Address) -> Result<u128, Self::AdapterError> {
         self.escrow(sender_id)
     }
     async fn subtract_escrow(
         &self,
         sender_id: Address,
         value: u128,
-    ) -> Result<(), Self::StrategyError> {
+    ) -> Result<(), Self::AdapterError> {
         self.reduce_escrow(sender_id, value)
     }
 
-    async fn verify_signer(&self, signer_address: Address) -> Result<bool, Self::StrategyError> {
+    async fn verify_signer(&self, signer_address: Address) -> Result<bool, Self::AdapterError> {
         Ok(self
             .sender_address
             .map(|sender| signer_address == sender)

tap_core/src/manager/context/memory.rs

@@ -12,7 +12,7 @@
 
 #[cfg(feature = "in_memory")]
 pub mod context;
-pub mod strategy;
+pub mod adapters;
 mod tap_manager;
 
 pub use tap_manager::Manager;