Simplifying lifetimes

src/main.rs

@@ -221,7 +221,7 @@ async fn update_status(
 }
 
 pub struct Ledger {
-    _inner: verax::Ledger<'static, verax::storage::Cache<'static, verax::storage::SQLite<'static>>>,
+    _inner: verax::Ledger<verax::storage::Cache<verax::storage::SQLite>>,
 }
 
 #[actix_web::main]

utxo/src/ledger.rs

@@ -2,29 +2,27 @@ use crate::{
     storage::Storage, transaction::Type, AccountId, Amount, AssetManager, Error, Payment,
     PaymentId, Status, Transaction, TransactionId,
 };
-use std::{cmp::Ordering, collections::HashMap, marker::PhantomData};
+use std::{cmp::Ordering, collections::HashMap};
 
 /// The Verax ledger
 #[derive(Clone, Debug)]
-pub struct Ledger<'a, S>
+pub struct Ledger<S>
 where
-    S: Storage<'a> + Sync + Send,
+    S: Storage + Sync + Send,
 {
     storage: S,
     asset_manager: AssetManager,
-    _phantom: PhantomData<&'a ()>,
 }
 
-impl<'a, S> Ledger<'a, S>
+impl<S> Ledger<S>
 where
-    S: Storage<'a> + Sync + Send,
+    S: Storage + Sync + Send,
 {
     /// Creates a new ledger instance
     pub fn new(storage: S, asset_manager: AssetManager) -> Self {
         Self {
             storage,
             asset_manager,
-            _phantom: PhantomData,
         }
     }
 
@@ -171,7 +169,7 @@ where
     /// otherwise it will fail. A failure in any execution will render the
     /// entire operation as failed but no funds will be locked.
     pub async fn new_transaction(
-        &'a self,
+        &self,
         reference: String,
         status: Status,
         from: Vec<(AccountId, Amount)>,
@@ -204,7 +202,7 @@ where
     /// accounts and amounts, to keep the upstream API simple, this function
     /// only accepts a single account and amount to credit
     pub async fn deposit(
-        &'a self,
+        &self,
         account: &AccountId,
         amount: Amount,
         status: Status,
@@ -223,7 +221,7 @@ where
     /// single input (single account and single amount). This is because the
     /// natural behaviour is to have withdrawals from a single account.
     pub async fn withdrawal(
-        &'a self,
+        &self,
         account: &AccountId,
         amount: Amount,
         status: Status,
@@ -241,13 +239,13 @@ where
     }
 
     /// Returns the payment object by a given payment id
-    pub async fn get_payment_info(&'a self, payment_id: &PaymentId) -> Result<Payment, Error> {
+    pub async fn get_payment_info(&self, payment_id: &PaymentId) -> Result<Payment, Error> {
         Ok(self.storage.get_payment(payment_id).await?)
     }
 
     /// Returns the transaction object by a given transaction id
     pub async fn get_transaction(
-        &'a self,
+        &self,
         transaction_id: &TransactionId,
     ) -> Result<Transaction, Error> {
         Ok(self
@@ -261,7 +259,7 @@ where
     /// sorted by transaction type. The transactions are sorted from newest to
     /// oldest.
     pub async fn get_transactions(
-        &'a self,
+        &self,
         account_id: &AccountId,
         types: Vec<Type>,
     ) -> Result<Vec<Transaction>, Error> {
@@ -284,7 +282,7 @@ where
     /// Attempts to change the status of a given transaction id. On success the
     /// new transaction object is returned, otherwise an error is returned.
     pub async fn change_status(
-        &'a self,
+        &self,
         transaction_id: &TransactionId,
         new_status: Status,
         reason: String,

utxo/src/storage/cache/batch.rs

@@ -1,7 +1,7 @@
 use super::CacheStorage;
 use crate::{
     changelog::Changelog,
-    storage::{Batch, Error, Storage},
+    storage::{Batch, Error},
     transaction::from_db,
     AccountId, Amount, Payment, PaymentId, Status, Transaction, TransactionId,
 };
@@ -15,11 +15,11 @@ pub enum Ids {
     Account(AccountId),
 }
 
-pub struct CacheBatch<'a, S>
+pub struct CacheBatch<'a, B>
 where
-    S: Storage<'a>,
+    B: Batch<'a> + Send,
 {
-    inner: S::Batch,
+    inner: B,
     payments: CacheStorage<PaymentId, Payment>,
     balances: CacheStorage<AccountId, Vec<Amount>>,
     transactions: CacheStorage<TransactionId, from_db::Transaction>,
@@ -27,12 +27,12 @@ where
     _phantom: PhantomData<&'a ()>,
 }
 
-impl<'a, S> CacheBatch<'a, S>
+impl<'a, B> CacheBatch<'a, B>
 where
-    S: Storage<'a> + Sync + Send,
+    B: Batch<'a> + Send,
 {
     pub fn new(
-        batch: S::Batch,
+        batch: B,
         payments: CacheStorage<PaymentId, Payment>,
         balances: CacheStorage<AccountId, Vec<Amount>>,
         transactions: CacheStorage<TransactionId, from_db::Transaction>,
@@ -49,9 +49,9 @@ where
 }
 
 #[async_trait::async_trait]
-impl<'a, S> Batch<'a> for CacheBatch<'a, S>
+impl<'a, B> Batch<'a> for CacheBatch<'a, B>
 where
-    S: Storage<'a> + Sync + Send,
+    B: Batch<'a> + Send,
 {
     async fn commit(self) -> Result<(), Error> {
         let mut payments = self.payments.write().await;

utxo/src/storage/cache/mod.rs

@@ -8,7 +8,7 @@ use crate::{
     AccountId, Amount, Payment, PaymentId, TransactionId, Type,
 };
 use serde::{de::DeserializeOwned, Serialize};
-use std::{collections::HashMap, marker::PhantomData, sync::Arc};
+use std::{collections::HashMap, sync::Arc};
 use tokio::sync::RwLock;
 
 mod batch;
@@ -20,20 +20,19 @@ pub(crate) type CacheStorage<K, V> = Arc<RwLock<HashMap<K, V>>>;
 /// This cache will wrap any actual storage and will add an in memory caching to
 /// offer better performance. This layer will also manager cache eviction and
 /// invalidation.
-pub struct Cache<'a, S>
+pub struct Cache<S>
 where
-    S: Storage<'a> + Sync + Send,
+    S: Storage + Sync + Send,
 {
     payments: CacheStorage<PaymentId, Payment>,
     balances: CacheStorage<AccountId, Vec<Amount>>,
     transactions: CacheStorage<TransactionId, Transaction>,
     inner: S,
-    _phantom: PhantomData<&'a ()>,
 }
 
-impl<'a, S> Cache<'a, S>
+impl<S> Cache<S>
 where
-    S: Storage<'a> + Sync + Send,
+    S: Storage + Sync + Send,
 {
     /// Create a new cache storage.
     pub fn new(storage: S) -> Self {
@@ -42,19 +41,20 @@ where
             balances: Arc::new(RwLock::new(HashMap::new())),
             transactions: Arc::new(RwLock::new(HashMap::new())),
             inner: storage,
-            _phantom: PhantomData,
         }
     }
 }
 
 #[async_trait::async_trait]
-impl<'a, S> Storage<'a> for Cache<'a, S>
+impl<S> Storage for Cache<S>
 where
-    S: Storage<'a> + Sync + Send,
+    S: Storage + Sync + Send,
 {
-    type Batch = batch::CacheBatch<'a, S>;
+    type Batch<'a> = batch::CacheBatch<'a, S::Batch<'a> >
+    where
+        Self: 'a;
 
-    async fn begin(&'a self) -> Result<Self::Batch, Error> {
+    async fn begin<'a>(&'a self) -> Result<Self::Batch<'a>, Error> {
         Ok(batch::CacheBatch::new(
             self.inner.begin().await?,
             self.payments.clone(),
@@ -146,7 +146,7 @@ mod test {
     use sqlx::sqlite::{SqliteConnectOptions, SqlitePoolOptions};
     use std::fs::remove_file;
 
-    async fn get_instance(assets: AssetManager, test: &str) -> Cache<'static, SQLite<'static>> {
+    async fn get_instance(assets: AssetManager, test: &str) -> Cache<SQLite> {
         let path = format!("/tmp/cache-{}.db", test);
         let _ = remove_file(&path);
         let settings = path
@@ -166,10 +166,7 @@ mod test {
 
     storage_test_suite!();
 
-    pub async fn get_ledger_and_asset_manager() -> (
-        AssetManager,
-        Ledger<'static, Cache<'static, SQLite<'static>>>,
-    ) {
+    pub async fn get_ledger_and_asset_manager() -> (AssetManager, Ledger<Cache<SQLite>>) {
         let pool = SqlitePoolOptions::new()
             .max_connections(1)
             .idle_timeout(None)

utxo/src/storage/mod.rs

@@ -118,12 +118,14 @@ pub trait Batch<'a> {
 
 #[async_trait::async_trait]
 /// Main storage layer
-pub trait Storage<'a> {
+pub trait Storage {
     /// The batch trait.
     ///
     /// This batch is needed to perform the changes in the transactions and
     /// payments in a atomic way
-    type Batch: Batch<'a> + Send;
+    type Batch<'a>: Batch<'a> + Send
+    where
+        Self: 'a;
 
     /// Begins a transaction
     ///
@@ -134,7 +136,7 @@ pub trait Storage<'a> {
     /// the changes in the transactions and payments.
     ///
     /// The batch has also a rollback
-    async fn begin(&'a self) -> Result<Self::Batch, Error>;
+    async fn begin<'a>(&'a self) -> Result<Self::Batch<'a>, Error>;
 
     /// Returns a payment object by ID.
     async fn get_payment(&self, id: &PaymentId) -> Result<Payment, Error>;
@@ -229,7 +231,7 @@ pub mod test {
 
     pub async fn transaction<'a, T>(storage: &'a T, assets: AssetManager)
     where
-        T: Storage<'a>,
+        T: Storage,
     {
         let deposit = Transaction::new_external_deposit(
             "test reference".to_owned(),
@@ -255,7 +257,7 @@ pub mod test {
 
     pub async fn transaction_not_available_until_commit<'a, T>(storage: &'a T, assets: AssetManager)
     where
-        T: Storage<'a>,
+        T: Storage,
     {
         let deposit = Transaction::new_external_deposit(
             "test reference".to_owned(),
@@ -282,7 +284,7 @@ pub mod test {
 
     pub async fn does_not_update_spent_payments<'a, T>(storage: &'a T, assets: AssetManager)
     where
-        T: Storage<'a>,
+        T: Storage,
     {
         let mut writer = storage.begin().await.expect("writer");
         let mut rng = rand::thread_rng();
@@ -340,7 +342,7 @@ pub mod test {
 
     pub async fn pending_new_payments_are_not_spendable<'a, T>(storage: &'a T, assets: AssetManager)
     where
-        T: Storage<'a>,
+        T: Storage,
     {
         not_spendable_new_payments_not_spendable(storage, assets, Status::Pending).await
     }
@@ -349,7 +351,7 @@ pub mod test {
         storage: &'a T,
         assets: AssetManager,
     ) where
-        T: Storage<'a>,
+        T: Storage,
     {
         not_spendable_new_payments_not_spendable(storage, assets, Status::Processing).await
     }
@@ -358,21 +360,21 @@ pub mod test {
         storage: &'a T,
         assets: AssetManager,
     ) where
-        T: Storage<'a>,
+        T: Storage,
     {
         not_spendable_new_payments_not_spendable(storage, assets, Status::Cancelled).await
     }
 
     pub async fn failed_new_payments_are_not_spendable<'a, T>(storage: &'a T, assets: AssetManager)
     where
-        T: Storage<'a>,
+        T: Storage,
     {
         not_spendable_new_payments_not_spendable(storage, assets, Status::Failed).await
     }
 
     pub async fn does_not_spend_unspendable_payments<'a, T>(storage: &'a T, assets: AssetManager)
     where
-        T: Storage<'a>,
+        T: Storage,
     {
         let mut writer = storage.begin().await.expect("writer");
         let mut rng = rand::thread_rng();
@@ -418,7 +420,7 @@ pub mod test {
 
     pub async fn sorted_unspent_payments<'a, T>(storage: &'a T, assets: AssetManager)
     where
-        T: Storage<'a>,
+        T: Storage,
     {
         let mut writer = storage.begin().await.expect("writer");
         let accounts: Vec<AccountId> = (0..10)
@@ -480,7 +482,7 @@ pub mod test {
 
     pub async fn relate_account_to_transaction<'a, T>(storage: &'a T, assets: AssetManager)
     where
-        T: Storage<'a>,
+        T: Storage,
     {
         let account1: AccountId = "alice1".parse().expect("account");
         let account2: AccountId = "alice2".parse().expect("account");
@@ -551,7 +553,7 @@ pub mod test {
         assets: AssetManager,
         status: Status,
     ) where
-        T: Storage<'a>,
+        T: Storage,
     {
         let mut writer = storage.begin().await.expect("writer");
         let mut rng = rand::thread_rng();

utxo/src/storage/sqlite/mod.rs

@@ -12,7 +12,7 @@ use chrono::NaiveDateTime;
 use futures::TryStreamExt;
 use serde::{de::DeserializeOwned, Serialize};
 use sqlx::{sqlite::SqliteRow, Executor, Row, SqliteConnection};
-use std::{collections::HashMap, marker::PhantomData, ops::Deref};
+use std::{collections::HashMap, ops::Deref};
 
 mod batch;
 
@@ -20,20 +20,15 @@ pub use batch::Batch;
 pub use sqlx::sqlite::{SqliteConnectOptions, SqlitePoolOptions};
 
 /// SQLite storage layer for Verax
-pub struct SQLite<'a> {
+pub struct SQLite {
     db: sqlx::SqlitePool,
     asset_manager: AssetManager,
-    _phantom: PhantomData<&'a ()>,
 }
 
-impl<'a> SQLite<'a> {
+impl SQLite {
     /// Creates a new Verax SQLite storage layer. It takes an instance of the asset_manager
     pub fn new(db: sqlx::SqlitePool, asset_manager: AssetManager) -> Self {
-        Self {
-            db,
-            asset_manager,
-            _phantom: PhantomData,
-        }
+        Self { db, asset_manager }
     }
 
     /// Creates all the tables and indexes that are needed
@@ -244,10 +239,12 @@ impl<'a> SQLite<'a> {
 }
 
 #[async_trait::async_trait]
-impl<'a> Storage<'a> for SQLite<'a> {
-    type Batch = Batch<'a>;
+impl Storage for SQLite {
+    type Batch<'a> = Batch<'a>
+    where
+    Self: 'a;
 
-    async fn begin(&'a self) -> Result<Self::Batch, Error> {
+    async fn begin<'a>(&'a self) -> Result<Self::Batch<'a>, Error> {
         self.db
             .begin()
             .await
@@ -625,7 +622,7 @@ mod test {
     use sqlx::sqlite::{SqliteConnectOptions, SqlitePoolOptions};
     use std::fs::remove_file;
 
-    async fn get_instance(assets: AssetManager, test: &str) -> SQLite<'static> {
+    async fn get_instance(assets: AssetManager, test: &str) -> SQLite {
         let path = format!("/tmp/{}.db", test);
         let _ = remove_file(&path);
         let settings = path

utxo/src/tests/mod.rs

@@ -5,9 +5,7 @@ use crate::{
 use sqlx::sqlite::SqlitePoolOptions;
 
 #[allow(unused)]
-pub async fn get_file_asset_manager_and_ledger<'a>(
-    name: &str,
-) -> (AssetManager, Ledger<'static, SQLite<'static>>) {
+pub async fn get_file_asset_manager_and_ledger<'a>(name: &str) -> (AssetManager, Ledger<SQLite>) {
     let pool = SqlitePoolOptions::new()
         .max_connections(1)
         .idle_timeout(None)
@@ -26,7 +24,7 @@ pub async fn get_file_asset_manager_and_ledger<'a>(
     (assets.clone(), Ledger::new(db, assets))
 }
 
-pub async fn get_asset_manager_and_ledger() -> (AssetManager, Ledger<'static, SQLite<'static>>) {
+pub async fn get_asset_manager_and_ledger() -> (AssetManager, Ledger<SQLite>) {
     let pool = SqlitePoolOptions::new()
         .max_connections(1)
         .idle_timeout(None)
@@ -46,7 +44,7 @@ pub async fn get_asset_manager_and_ledger() -> (AssetManager, Ledger<'static, SQ
 }
 
 pub async fn withdrawal(
-    ledger: &Ledger<'static, SQLite<'static>>,
+    ledger: &Ledger<SQLite>,
     account_id: &AccountId,
     status: Status,
     amount: Amount,
@@ -58,13 +56,9 @@ pub async fn withdrawal(
         .clone())
 }
 
-pub async fn deposit<'a, S>(
-    ledger: &'a Ledger<'a, S>,
-    account_id: &AccountId,
-    amount: Amount,
-) -> TransactionId
+pub async fn deposit<S>(ledger: &Ledger<S>, account_id: &AccountId, amount: Amount) -> TransactionId
 where
-    S: Storage<'a> + Send + Sync,
+    S: Storage + Send + Sync,
 {
     ledger
         .deposit(account_id, amount, Status::Settled, "Test".to_owned())

utxo/src/transaction/inner.rs

@@ -293,7 +293,7 @@ impl Transaction {
     /// This is equivalent to changes the status to Settle and to persist
     pub async fn settle<'a, S>(&mut self, storage: &'a S, reason: String) -> Result<(), Error>
     where
-        S: Storage<'a> + Sync + Send,
+        S: Storage + Sync + Send,
     {
         self.change_status(Status::Settled, reason)?;
         self.persist::<S>(storage).await
@@ -484,7 +484,7 @@ impl Transaction {
     /// This method is not idempotent, and it will fail if the transaction if the requested update is not allowed.
     pub async fn persist<'a, S>(&mut self, storage: &'a S) -> Result<(), Error>
     where
-        S: Storage<'a> + Sync + Send,
+        S: Storage + Sync + Send,
     {
         let mut batch = storage.begin().await?;
         if let Some(status) = batch.get_payment_status(&self.id).await? {