WIP

utxo/src/cache.rs

@@ -0,0 +1,234 @@
+use crate::{
+    amount::AmountCents,
+    asset::AssetId,
+    changelog::Changelog,
+    storage::{Batch, Error, Storage},
+    transaction::from_db::Transaction,
+    AccountId, Amount, Payment, PaymentId, TransactionId, Type,
+};
+use serde::{de::DeserializeOwned, Serialize};
+use std::{collections::HashMap, marker::PhantomData, sync::Arc};
+use tokio::sync::RwLock;
+
+pub struct Cache<'a, S>
+where
+    S: Storage<'a> + Sync + Send,
+{
+    payments: Arc<RwLock<HashMap<PaymentId, Payment>>>,
+    balances: Arc<RwLock<HashMap<AccountId, Vec<Amount>>>>,
+    transactions: Arc<RwLock<HashMap<TransactionId, Transaction>>>,
+    inner: S,
+    _phantom: PhantomData<&'a ()>,
+}
+
+impl<'a, S> Cache<'a, S>
+where
+    S: Storage<'a> + Sync + Send,
+{
+    pub fn new(storage: S) -> Self {
+        Self {
+            payments: Arc::new(RwLock::new(HashMap::new())),
+            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>
+where
+    S: Storage<'a> + Sync + Send,
+{
+    type Batch = S::Batch;
+
+    async fn begin(&'a self) -> Result<Self::Batch, Error> {
+        self.inner.begin().await
+    }
+
+    async fn get_payment(&self, id: &PaymentId) -> Result<Payment, Error> {
+        let payments = self.payments.read().await;
+        if let Some(payment) = payments.get(id).cloned() {
+            Ok(payment)
+        } else {
+            drop(payments);
+            let result = self.inner.get_payment(id).await?;
+            self.payments
+                .write()
+                .await
+                .insert(id.clone(), result.clone());
+            Ok(result)
+        }
+    }
+
+    async fn get_balance(&self, account_id: &AccountId) -> Result<Vec<Amount>, Error> {
+        let cache = self.balances.read().await;
+        if let Some(balances) = cache.get(account_id).cloned() {
+            Ok(balances)
+        } else {
+            drop(cache);
+            let result = self.inner.get_balance(account_id).await?;
+            self.balances
+                .write()
+                .await
+                .insert(account_id.clone(), result.clone());
+            Ok(result)
+        }
+    }
+
+    async fn get_transaction(&self, id: &TransactionId) -> Result<Transaction, Error> {
+        let transactions = self.transactions.read().await;
+        if let Some(transaction) = transactions.get(id).cloned() {
+            Ok(transaction)
+        } else {
+            drop(transactions);
+            let result = self.inner.get_transaction(id).await?;
+            self.transactions
+                .write()
+                .await
+                .insert(id.clone(), result.clone());
+            Ok(result)
+        }
+    }
+
+    async fn get_changelogs<T: DeserializeOwned + Serialize + Send + Sync>(
+        &self,
+        object_id: Vec<u8>,
+    ) -> Result<Vec<Changelog<T>>, Error> {
+        self.inner.get_changelogs(object_id).await
+    }
+
+    async fn get_unspent_payments(
+        &self,
+        account: &AccountId,
+        asset: AssetId,
+        target_amount: AmountCents,
+    ) -> Result<Vec<Payment>, Error> {
+        self.inner
+            .get_unspent_payments(account, asset, target_amount)
+            .await
+    }
+
+    async fn get_transactions(
+        &self,
+        account: &AccountId,
+        types: &[Type],
+        tags: &[String],
+    ) -> Result<Vec<Transaction>, Error> {
+        self.inner.get_transactions(account, types, tags).await
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::{
+        storage_test_suite, tests::deposit, AssetDefinition, AssetManager, Ledger, SQLite, Status,
+    };
+    use sqlx::sqlite::{SqliteConnectOptions, SqlitePoolOptions};
+    use std::{fs::remove_file, path::Path};
+
+    async fn get_instance(assets: AssetManager, test: &str) -> Cache<'static, SQLite<'static>> {
+        let path = format!("/tmp/cache-{}.db", test);
+        let _ = remove_file(&path);
+        let settings = path
+            .parse::<SqliteConnectOptions>()
+            .expect("valid settings")
+            .create_if_missing(true);
+
+        let pool = SqlitePoolOptions::new()
+            .connect_with(settings)
+            .await
+            .expect("pool");
+
+        let db = SQLite::new(pool, assets);
+        db.setup().await.expect("setup");
+        Cache::new(db)
+    }
+
+    storage_test_suite!();
+
+    pub async fn get_ledger_and_asset_manager() -> (
+        AssetManager,
+        Ledger<'static, Cache<'static, SQLite<'static>>>,
+    ) {
+        let pool = SqlitePoolOptions::new()
+            .max_connections(1)
+            .idle_timeout(None)
+            .max_lifetime(None)
+            .connect(":memory:")
+            .await
+            .expect("pool");
+
+        let assets = AssetManager::new(vec![
+            AssetDefinition::new(1, "BTC", 8),
+            AssetDefinition::new(2, "USD", 4),
+        ]);
+
+        let db = SQLite::new(pool, assets.clone());
+        db.setup().await.expect("setup");
+        (assets.clone(), Ledger::new(Cache::new(db), assets))
+    }
+
+    #[tokio::test]
+    async fn balances_updates() {
+        let source = "account1".parse::<AccountId>().expect("account");
+        let dest = "account2".parse::<AccountId>().expect("account");
+        let fee = "fee".parse::<AccountId>().expect("account");
+        let (assets, ledger) = get_ledger_and_asset_manager().await;
+
+        deposit(
+            &ledger,
+            &source,
+            assets.amount_by_and_cents(2, 1000).expect("amount"),
+        )
+        .await;
+        deposit(
+            &ledger,
+            &source,
+            assets.amount_by_and_cents(2, 2000).expect("amount"),
+        )
+        .await;
+
+        assert_eq!(
+            vec![assets.amount_by_and_cents(2, 3000).expect("amount")],
+            ledger.get_balance(&source).await.expect("balance")
+        );
+
+        ledger
+            .new_transaction(
+                "Exchange one".to_owned(),
+                Status::Settled,
+                vec![(
+                    source.clone(),
+                    assets.amount_by_and_cents(2, 1300).expect("amount"),
+                )],
+                vec![
+                    (
+                        dest.clone(),
+                        assets.amount_by_and_cents(2, 1250).expect("amount"),
+                    ),
+                    (
+                        fee.clone(),
+                        assets.amount_by_and_cents(2, 50).expect("amount"),
+                    ),
+                ],
+            )
+            .await
+            .expect("valid tx");
+
+        assert_eq!(
+            vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
+            ledger.get_balance(&source).await.expect("balance")
+        );
+        assert_eq!(
+            vec![assets.amount_by_and_cents(2, 1250).expect("amount")],
+            ledger.get_balance(&dest).await.expect("balance")
+        );
+        assert_eq!(
+            vec![assets.amount_by_and_cents(2, 50).expect("amount")],
+            ledger.get_balance(&fee).await.expect("balance")
+        );
+    }
+}

utxo/src/ledger.rs

@@ -1,33 +1,30 @@
 use crate::{
-    storage::{Batch, Storage},
-    transaction::Type,
-    AccountId, Amount, AssetManager, Error, Payment, PaymentId, Status, Transaction, TransactionId,
+    storage::Storage, transaction::Type, AccountId, Amount, AssetManager, Error, Payment,
+    PaymentId, Status, Transaction, TransactionId,
 };
-use std::{cmp::Ordering, collections::HashMap};
+use std::{cmp::Ordering, collections::HashMap, marker::PhantomData};
 
 /// The Verax ledger
 #[derive(Clone, Debug)]
-pub struct Ledger<'a, B, S>
+pub struct Ledger<'a, S>
 where
-    B: Batch<'a>,
-    S: Storage<'a, B> + Sync + Send,
+    S: Storage<'a> + Sync + Send,
 {
     storage: S,
     asset_manager: AssetManager,
-    _phantom: std::marker::PhantomData<&'a B>,
+    _phantom: PhantomData<&'a ()>,
 }
 
-impl<'a, B, S> Ledger<'a, B, S>
+impl<'a, S> Ledger<'a, S>
 where
-    B: Batch<'a>,
-    S: Storage<'a, B> + Sync + Send,
+    S: Storage<'a> + Sync + Send,
 {
     /// Creates a new ledger instance
     pub fn new(storage: S, asset_manager: AssetManager) -> Self {
         Self {
             storage,
             asset_manager,
-            _phantom: std::marker::PhantomData,
+            _phantom: PhantomData,
         }
     }
 

utxo/src/lib.rs

@@ -23,6 +23,7 @@
 mod amount;
 mod asset;
 mod asset_manager;
+mod cache;
 mod changelog;
 mod error;
 mod id;

utxo/src/payment.rs

@@ -2,7 +2,7 @@ use crate::{changelog::Changelog, AccountId, Amount, Status, TransactionId};
 use serde::{Deserialize, Serialize, Serializer};
 use std::ops::Deref;
 
-#[derive(Clone, Debug, Eq, Ord, PartialOrd, PartialEq)]
+#[derive(Clone, Debug, Eq, Ord, Hash, PartialOrd, PartialEq)]
 /// PaymentID
 ///
 /// This is the payment ID. The payment ID has two public members, which is

utxo/src/sqlite/mod.rs

@@ -244,8 +244,10 @@ impl<'a> SQLite<'a> {
 }
 
 #[async_trait::async_trait]
-impl<'a> Storage<'a, Batch<'a>> for SQLite<'a> {
-    async fn begin(&'a self) -> Result<Batch<'a>, Error> {
+impl<'a> Storage<'a> for SQLite<'a> {
+    type Batch = Batch<'a>;
+
+    async fn begin(&'a self) -> Result<Self::Batch, Error> {
         self.db
             .begin()
             .await

utxo/src/storage.rs

@@ -111,10 +111,13 @@ pub trait Batch<'a> {
 
 #[async_trait::async_trait]
 /// Main storage layer
-pub trait Storage<'a, B>
-where
-    B: Batch<'a>,
-{
+pub trait Storage<'a> {
+    /// The batch trait.
+    ///
+    /// This batch is needed to perform the changes in the transactions and
+    /// payments in a atomic way
+    type Batch: Batch<'a>;
+
     /// Begins a transaction
     ///
     /// A transaction prepares the storage for a batch of operations, where all
@@ -124,7 +127,7 @@ where
     /// the changes in the transactions and payments.
     ///
     /// The batch has also a rollback
-    async fn begin(&'a self) -> Result<B, Error>;
+    async fn begin(&'a self) -> Result<Self::Batch, Error>;
 
     /// Returns a payment object by ID.
     async fn get_payment(&self, id: &PaymentId) -> Result<Payment, Error>;
@@ -135,7 +138,6 @@ where
         if payment.is_spendable() {
             Ok(payment)
         } else {
-            println!("{:?}", payment);
             Err(Error::NotFound)
         }
     }
@@ -218,10 +220,9 @@ pub mod test {
         };
     }
 
-    pub async fn transaction<'a, T, B>(storage: &'a T, assets: AssetManager)
+    pub async fn transaction<'a, T>(storage: &'a T, assets: AssetManager)
     where
-        T: Storage<'a, B>,
-        B: Batch<'a>,
+        T: Storage<'a>,
     {
         let deposit = Transaction::new_external_deposit(
             "test reference".to_owned(),
@@ -245,12 +246,9 @@ pub mod test {
         assert!(storage.get_transaction(&deposit.id()).await.is_ok());
     }
 
-    pub async fn transaction_not_available_until_commit<'a, T, B>(
-        storage: &'a T,
-        assets: AssetManager,
-    ) where
-        T: Storage<'a, B>,
-        B: Batch<'a>,
+    pub async fn transaction_not_available_until_commit<'a, T>(storage: &'a T, assets: AssetManager)
+    where
+        T: Storage<'a>,
     {
         let deposit = Transaction::new_external_deposit(
             "test reference".to_owned(),
@@ -275,10 +273,9 @@ pub mod test {
         assert!(storage.get_transaction(&deposit.id()).await.is_ok());
     }
 
-    pub async fn does_not_update_spent_payments<'a, T, B>(storage: &'a T, assets: AssetManager)
+    pub async fn does_not_update_spent_payments<'a, T>(storage: &'a T, assets: AssetManager)
     where
-        T: Storage<'a, B>,
-        B: Batch<'a>,
+        T: Storage<'a>,
     {
         let mut writer = storage.begin().await.expect("writer");
         let mut rng = rand::thread_rng();
@@ -334,50 +331,41 @@ pub mod test {
         }
     }
 
-    pub async fn pending_new_payments_are_not_spendable<'a, T, B>(
-        storage: &'a T,
-        assets: AssetManager,
-    ) where
-        T: Storage<'a, B>,
-        B: Batch<'a>,
+    pub async fn pending_new_payments_are_not_spendable<'a, T>(storage: &'a T, assets: AssetManager)
+    where
+        T: Storage<'a>,
     {
         not_spendable_new_payments_not_spendable(storage, assets, Status::Pending).await
     }
 
-    pub async fn processing_new_payments_are_not_spendable<'a, T, B>(
+    pub async fn processing_new_payments_are_not_spendable<'a, T>(
         storage: &'a T,
         assets: AssetManager,
     ) where
-        T: Storage<'a, B>,
-        B: Batch<'a>,
+        T: Storage<'a>,
     {
         not_spendable_new_payments_not_spendable(storage, assets, Status::Processing).await
     }
 
-    pub async fn cancelled_new_payments_are_not_spendable<'a, T, B>(
+    pub async fn cancelled_new_payments_are_not_spendable<'a, T>(
         storage: &'a T,
         assets: AssetManager,
     ) where
-        T: Storage<'a, B>,
-        B: Batch<'a>,
+        T: Storage<'a>,
     {
         not_spendable_new_payments_not_spendable(storage, assets, Status::Cancelled).await
     }
 
-    pub async fn failed_new_payments_are_not_spendable<'a, T, B>(
-        storage: &'a T,
-        assets: AssetManager,
-    ) where
-        T: Storage<'a, B>,
-        B: Batch<'a>,
+    pub async fn failed_new_payments_are_not_spendable<'a, T>(storage: &'a T, assets: AssetManager)
+    where
+        T: Storage<'a>,
     {
         not_spendable_new_payments_not_spendable(storage, assets, Status::Failed).await
     }
 
-    pub async fn does_not_spend_unspendable_payments<'a, T, B>(storage: &'a T, assets: AssetManager)
+    pub async fn does_not_spend_unspendable_payments<'a, T>(storage: &'a T, assets: AssetManager)
     where
-        T: Storage<'a, B>,
-        B: Batch<'a>,
+        T: Storage<'a>,
     {
         let mut writer = storage.begin().await.expect("writer");
         let mut rng = rand::thread_rng();
@@ -421,10 +409,9 @@ pub mod test {
         }
     }
 
-    pub async fn sorted_unspent_payments<'a, T, B>(storage: &'a T, assets: AssetManager)
+    pub async fn sorted_unspent_payments<'a, T>(storage: &'a T, assets: AssetManager)
     where
-        T: Storage<'a, B>,
-        B: Batch<'a>,
+        T: Storage<'a>,
     {
         let mut writer = storage.begin().await.expect("writer");
         let accounts: Vec<AccountId> = (0..10)
@@ -484,10 +471,9 @@ pub mod test {
         assert!(at_least_one_negative_amount);
     }
 
-    pub async fn relate_account_to_transaction<'a, T, B>(storage: &'a T, assets: AssetManager)
+    pub async fn relate_account_to_transaction<'a, T>(storage: &'a T, assets: AssetManager)
     where
-        T: Storage<'a, B>,
-        B: Batch<'a>,
+        T: Storage<'a>,
     {
         let account1: AccountId = "alice1".parse().expect("account");
         let account2: AccountId = "alice2".parse().expect("account");
@@ -553,13 +539,12 @@ pub mod test {
         }
     }
 
-    async fn not_spendable_new_payments_not_spendable<'a, T, B>(
+    async fn not_spendable_new_payments_not_spendable<'a, T>(
         storage: &'a T,
         assets: AssetManager,
         status: Status,
     ) where
-        T: Storage<'a, B>,
-        B: Batch<'a>,
+        T: Storage<'a>,
     {
         let mut writer = storage.begin().await.expect("writer");
         let mut rng = rand::thread_rng();

utxo/src/tests/deposit.rs

@@ -1,10 +1,10 @@
-use super::{deposit, get_instance};
+use super::{deposit, get_asset_manager_and_ledger};
 use crate::{AccountId, Status};
 
 #[tokio::test]
 async fn pending_deposit_and_failure() {
     let source = "account1".parse::<AccountId>().expect("account");
-    let (assets, ledger) = get_instance().await;
+    let (assets, ledger) = get_asset_manager_and_ledger().await;
     let id = ledger
         .deposit(
             &source,
@@ -40,7 +40,7 @@ async fn deposit_and_transfer() {
     let source = "account1".parse::<AccountId>().expect("account");
     let dest = "account2".parse::<AccountId>().expect("account");
     let fee = "fee".parse::<AccountId>().expect("account");
-    let (assets, ledger) = get_instance().await;
+    let (assets, ledger) = get_asset_manager_and_ledger().await;
 
     deposit(
         &ledger,
@@ -101,7 +101,7 @@ async fn balance_decreases_while_pending_spending_and_confirm() {
     let source = "account1".parse::<AccountId>().expect("account");
     let dest = "account2".parse::<AccountId>().expect("account");
     let fee = "fee".parse::<AccountId>().expect("account");
-    let (assets, ledger) = get_instance().await;
+    let (assets, ledger) = get_asset_manager_and_ledger().await;
 
     deposit(
         &ledger,
@@ -176,7 +176,7 @@ async fn balance_decreases_while_pending_spending_and_cancel() {
     let source = "account1".parse::<AccountId>().expect("account");
     let dest = "account2".parse::<AccountId>().expect("account");
     let fee = "fee".parse::<AccountId>().expect("account");
-    let (assets, ledger) = get_instance().await;
+    let (assets, ledger) = get_asset_manager_and_ledger().await;
 
     deposit(
         &ledger,
@@ -245,7 +245,7 @@ async fn balance_decreases_while_pending_spending_and_failed() {
     let source = "account1".parse::<AccountId>().expect("account");
     let dest = "account2".parse::<AccountId>().expect("account");
     let fee = "fee".parse::<AccountId>().expect("account");
-    let (assets, ledger) = get_instance().await;
+    let (assets, ledger) = get_asset_manager_and_ledger().await;
 
     deposit(
         &ledger,

utxo/src/tests/mod.rs

@@ -1,16 +1,14 @@
 use crate::{
     asset_manager::AssetDefinition,
     sqlite::{Batch, SQLite},
+    storage::Storage,
     AccountId, Amount, AssetManager, Error, Ledger, Status, TransactionId,
 };
 use sqlx::sqlite::SqlitePoolOptions;
 
-pub async fn get_persistance_instance(
+pub async fn get_file_asset_manager_and_ledger<'a>(
     name: &str,
-) -> (
-    AssetManager,
-    Ledger<'static, Batch<'static>, SQLite<'static>>,
-) {
+) -> (AssetManager, Ledger<'static, SQLite<'static>>) {
     let pool = SqlitePoolOptions::new()
         .max_connections(1)
         .idle_timeout(None)
@@ -29,10 +27,7 @@ pub async fn get_persistance_instance(
     (assets.clone(), Ledger::new(db, assets))
 }
 
-pub async fn get_instance() -> (
-    AssetManager,
-    Ledger<'static, Batch<'static>, SQLite<'static>>,
-) {
+pub async fn get_asset_manager_and_ledger() -> (AssetManager, Ledger<'static, SQLite<'static>>) {
     let pool = SqlitePoolOptions::new()
         .max_connections(1)
         .idle_timeout(None)
@@ -52,7 +47,7 @@ pub async fn get_instance() -> (
 }
 
 pub async fn withdrawal(
-    ledger: &Ledger<'static, Batch<'static>, SQLite<'static>>,
+    ledger: &Ledger<'static, SQLite<'static>>,
     account_id: &AccountId,
     status: Status,
     amount: Amount,
@@ -64,11 +59,14 @@ pub async fn withdrawal(
         .clone())
 }
 
-pub async fn deposit(
-    ledger: &Ledger<'static, Batch<'static>, SQLite<'static>>,
+pub async fn deposit<'a, S>(
+    ledger: &'a Ledger<'a, S>,
     account_id: &AccountId,
     amount: Amount,
-) -> TransactionId {
+) -> TransactionId
+where
+    S: Storage<'a> + Send + Sync,
+{
     ledger
         .deposit(account_id, amount, Status::Settled, "Test".to_owned())
         .await

utxo/src/tests/negative_deposit.rs

@@ -1,4 +1,4 @@
-use super::{deposit, get_instance};
+use super::{deposit, get_asset_manager_and_ledger};
 use crate::{AccountId, Status};
 
 #[tokio::test]
@@ -6,7 +6,7 @@ async fn negative_deposit_prevent_spending() {
     let source = "account1".parse::<AccountId>().expect("account");
     let dest = "account2".parse::<AccountId>().expect("account");
     let fee = "fee".parse::<AccountId>().expect("account");
-    let (assets, ledger) = get_instance().await;
+    let (assets, ledger) = get_asset_manager_and_ledger().await;
 
     // Deposit some money
     deposit(
@@ -61,7 +61,7 @@ async fn negative_deposit_prevent_spending_payback() {
     let source = "account1".parse::<AccountId>().expect("account");
     let dest = "account2".parse::<AccountId>().expect("account");
     let fee = "fee".parse::<AccountId>().expect("account");
-    let (assets, ledger) = get_instance().await;
+    let (assets, ledger) = get_asset_manager_and_ledger().await;
 
     // Deposit some money
     deposit(

utxo/src/tests/tx.rs

@@ -1,4 +1,4 @@
-use super::{deposit, get_instance, get_persistance_instance};
+use super::{deposit, get_asset_manager_and_ledger};
 use crate::{AccountId, Status, Type};
 
 #[tokio::test]
@@ -9,7 +9,7 @@ async fn multi_account_transfers() {
         .collect::<Result<Vec<AccountId>, _>>()
         .expect("valid");
     let target = "target".parse::<AccountId>().expect("target account");
-    let (assets, ledger) = get_instance().await;
+    let (assets, ledger) = get_asset_manager_and_ledger().await;
 
     for account in &accounts {
         deposit(

utxo/src/tests/withdrawal.rs

@@ -1,4 +1,4 @@
-use super::{deposit, get_instance, withdrawal};
+use super::{deposit, get_asset_manager_and_ledger, withdrawal};
 use crate::{AccountId, Status};
 
 #[tokio::test]
@@ -6,7 +6,7 @@ async fn deposit_transfer_and_withdrawal() {
     let source = "account1".parse::<AccountId>().expect("account");
     let dest = "account2".parse::<AccountId>().expect("account");
     let fee = "fee".parse::<AccountId>().expect("account");
-    let (assets, ledger) = get_instance().await;
+    let (assets, ledger) = get_asset_manager_and_ledger().await;
 
     deposit(
         &ledger,
@@ -90,7 +90,7 @@ async fn fail_to_overwithdrawal() {
     let source = "account1".parse::<AccountId>().expect("account");
     let dest = "account2".parse::<AccountId>().expect("account");
     let fee = "fee".parse::<AccountId>().expect("account");
-    let (assets, ledger) = get_instance().await;
+    let (assets, ledger) = get_asset_manager_and_ledger().await;
 
     deposit(
         &ledger,
@@ -173,7 +173,7 @@ async fn cancelled_withdrawal() {
     let source = "account1".parse::<AccountId>().expect("account");
     let dest = "account2".parse::<AccountId>().expect("account");
     let fee = "fee".parse::<AccountId>().expect("account");
-    let (assets, ledger) = get_instance().await;
+    let (assets, ledger) = get_asset_manager_and_ledger().await;
 
     deposit(
         &ledger,
@@ -274,7 +274,7 @@ async fn cancelled_withdrawal() {
 #[tokio::test]
 async fn negative_withdrawal() {
     let source = "account1".parse::<AccountId>().expect("account");
-    let (assets, ledger) = get_instance().await;
+    let (assets, ledger) = get_asset_manager_and_ledger().await;
 
     deposit(
         &ledger,

utxo/src/transaction/from_db.rs

@@ -2,6 +2,7 @@ use super::{ChangelogEntry, Type};
 use crate::{changelog::Changelog, Payment, Status, TransactionId};
 use chrono::{DateTime, Utc};
 
+#[derive(Debug, Clone)]
 pub struct Transaction {
     pub id: TransactionId,
     pub spend: Vec<Payment>,

utxo/src/transaction/inner.rs

@@ -291,13 +291,12 @@ impl Transaction {
     /// Settles the current transaction
     ///
     /// This is equivalent to changes the status to Settle and to persist
-    pub async fn settle<'a, B, S>(&mut self, storage: &'a S, reason: String) -> Result<(), Error>
+    pub async fn settle<'a, S>(&mut self, storage: &'a S, reason: String) -> Result<(), Error>
     where
-        B: Batch<'a>,
-        S: Storage<'a, B> + Sync + Send,
+        S: Storage<'a> + Sync + Send,
     {
         self.change_status(Status::Settled, reason)?;
-        self.persist::<B, S>(storage).await
+        self.persist::<S>(storage).await
     }
 
     /// Changes the status of a given transaction
@@ -483,10 +482,9 @@ impl Transaction {
 
     /// Persists the changes done to this transaction object.
     /// This method is not idempotent, and it will fail if the transaction if the requested update is not allowed.
-    pub async fn persist<'a, B, S>(&mut self, storage: &'a S) -> Result<(), Error>
+    pub async fn persist<'a, S>(&mut self, storage: &'a S) -> Result<(), Error>
     where
-        B: Batch<'a>,
-        S: Storage<'a, B> + Sync + Send,
+        S: Storage<'a> + Sync + Send,
     {
         let mut batch = storage.begin().await?;
         if let Some(status) = batch.get_payment_status(&self.id).await? {