Merge pull request #1 from crodas/types

Add a better internal struct

client.js

@@ -99,6 +99,7 @@ async function test() {
   const t = await trade(1, "BTC/8", addr1, 26751.11, "USD/4", addr2);
   dbg(t);
   dbg(await change_status(t._id, 'processing',));
+  console.log('set settle')
   dbg(await change_status(t._id, 'settled'));
   dbg(await get_balance(addr1));
   dbg(await get_balance(addr2));

src/main.rs

@@ -136,7 +136,11 @@ async fn get_info(info: web::Path<AnyId>, ledger: web::Data<Ledger>) -> impl Res
             .get_transaction(&transaction_id)
             .await
             .map(|tx| {
-                if ledger._inner.get_status_manager().is_final(tx.status()) {
+                if ledger
+                    ._inner
+                    .get_status_manager()
+                    .is_final(&tx.revision.status)
+                {
                     HttpResponse::Ok()
                         .header(
                             "Cache-Control",

utxo/src/ledger.rs

@@ -149,7 +149,7 @@ where
             )
             .await?;
 
-            let creates = split_input.creates();
+            let creates = &split_input.creates;
             for i in 0..total {
                 // Spend the new payment
                 let index = i

utxo/src/lib.rs

@@ -48,5 +48,5 @@ pub use self::{
     payment::PaymentFrom,
     serde::*,
     status::Status,
-    transaction::{Transaction, Type},
+    transaction::*,
 };

utxo/src/status.rs

@@ -15,6 +15,13 @@ pub struct StatusManager {
     transition: HashMap<Status, Vec<Status>>,
 }
 
+#[derive(Debug, Clone, Copy)]
+pub enum StatusType {
+    Spendable,
+    Reverted,
+    NoChange,
+}
+
 /// Status error object
 #[derive(Debug, Serialize, thiserror::Error)]
 pub enum Error {
@@ -34,6 +41,16 @@ impl StatusManager {
             .ok_or(Error::UnknownStatus(status_name.to_owned()))
     }
 
+    pub fn typ(&self, status: &Status) -> StatusType {
+        if self.is_spendable(status) {
+            StatusType::Spendable
+        } else if self.is_reverted(status) {
+            StatusType::Reverted
+        } else {
+            StatusType::NoChange
+        }
+    }
+
     pub fn spendables(&self) -> &[Status] {
         &self.spendable
     }

utxo/src/storage/cache/batch.rs

@@ -1,8 +1,8 @@
 use super::CacheStorage;
 use crate::{
     payment::PaymentTo,
-    storage::{Batch, Error, Status},
-    AccountId, Amount, PaymentFrom, PaymentId, Transaction, TxId,
+    storage::{Batch, Error, ReceivedPaymentStatus},
+    AccountId, Amount, BaseTx, PaymentFrom, PaymentId, RevId, Revision, Transaction, TxId,
 };
 use std::{collections::HashMap, marker::PhantomData};
 
@@ -75,13 +75,6 @@ where
         Ok(())
     }
 
-    async fn get_and_lock_transaction(
-        &mut self,
-        transaction_id: &TxId,
-    ) -> Result<Transaction, Error> {
-        self.inner.get_and_lock_transaction(transaction_id).await
-    }
-
     async fn relate_account_to_transaction(
         &mut self,
         transaction_id: &TxId,
@@ -103,8 +96,8 @@ where
     async fn update_transaction_payments(
         &mut self,
         transaction_id: &TxId,
-        create_status: Status,
-        spend_status: Status,
+        create_status: ReceivedPaymentStatus,
+        spend_status: ReceivedPaymentStatus,
     ) -> Result<(usize, usize), Error> {
         self.to_invalidate
             .insert(Ids::Transaction(transaction_id.clone()), ());
@@ -113,7 +106,10 @@ where
             .await
     }
 
-    async fn get_payment_status(&mut self, transaction_id: &TxId) -> Result<Option<Status>, Error> {
+    async fn get_payment_status(
+        &mut self,
+        transaction_id: &TxId,
+    ) -> Result<Option<ReceivedPaymentStatus>, Error> {
         self.to_invalidate
             .insert(Ids::Transaction(transaction_id.clone()), ());
         self.inner.get_payment_status(transaction_id).await
@@ -123,7 +119,7 @@ where
         &mut self,
         transaction_id: &TxId,
         spends: Vec<PaymentId>,
-        status: Status,
+        status: ReceivedPaymentStatus,
     ) -> Result<(), Error> {
         for spend in &spends {
             self.to_invalidate.insert(Ids::Payment(spend.clone()), ());
@@ -137,7 +133,7 @@ where
         &mut self,
         transaction_id: &TxId,
         recipients: &[PaymentTo],
-        status: Status,
+        status: ReceivedPaymentStatus,
     ) -> Result<(), Error> {
         for recipient in recipients {
             self.to_invalidate
@@ -148,19 +144,46 @@ where
             .await
     }
 
-    async fn store_transaction(&mut self, transaction: &Transaction) -> Result<(), Error> {
+    async fn store_base_transaction(
+        &mut self,
+        transaction_id: &TxId,
+        transaction: &BaseTx,
+    ) -> Result<(), Error> {
         self.to_invalidate
-            .insert(Ids::Transaction(transaction.id().clone()), ());
-        self.inner.store_transaction(transaction).await
+            .insert(Ids::Transaction(transaction_id.clone()), ());
+        self.inner
+            .store_base_transaction(transaction_id, transaction)
+            .await
+    }
+
+    async fn store_revision(
+        &mut self,
+        revision_id: &RevId,
+        revision: &Revision,
+    ) -> Result<(), Error> {
+        self.inner.store_revision(revision_id, revision).await
+    }
+
+    async fn update_transaction_revision(
+        &mut self,
+        transaction_id: &TxId,
+        revision_id: &RevId,
+        previous_rev_id: Option<&RevId>,
+    ) -> Result<(), Error> {
+        self.to_invalidate
+            .insert(Ids::Transaction(transaction_id.clone()), ());
+        self.inner
+            .update_transaction_revision(transaction_id, revision_id, previous_rev_id)
+            .await
     }
 
     async fn tag_transaction(
         &mut self,
-        transaction: &Transaction,
+        transaction_id: &TxId,
         tags: &[String],
     ) -> Result<(), Error> {
         self.to_invalidate
-            .insert(Ids::Transaction(transaction.id().clone()), ());
-        self.inner.tag_transaction(transaction, tags).await
+            .insert(Ids::Transaction(transaction_id.clone()), ());
+        self.inner.tag_transaction(transaction_id, tags).await
     }
 }

utxo/src/storage/cache/mod.rs

@@ -2,8 +2,7 @@
 use crate::{
     amount::AmountCents,
     storage::{Error, Storage},
-    transaction::Transaction,
-    AccountId, Amount, Asset, PaymentFrom, PaymentId, TxId, Type,
+    AccountId, Amount, Asset, PaymentFrom, PaymentId, Transaction, TxId, Type,
 };
 use std::{collections::HashMap, sync::Arc};
 use tokio::sync::RwLock;

utxo/src/storage/mod.rs

@@ -1,7 +1,7 @@
 //! Storage layer trait
 use crate::{
-    amount::AmountCents, payment::PaymentTo, transaction::Type, AccountId, Amount, Asset,
-    PaymentFrom, PaymentId, Transaction, TxId,
+    amount::AmountCents, payment::PaymentTo, transaction::Type, AccountId, Amount, Asset, BaseTx,
+    PaymentFrom, PaymentId, RevId, Revision, Transaction, TxId,
 };
 //use chrono::{DateTime, Utc};
 use serde::Serialize;
@@ -15,7 +15,7 @@ pub use self::sqlite::SQLite;
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug, Serialize)]
 /// Storage Payment Status
-pub enum Status {
+pub enum ReceivedPaymentStatus {
     ///  The payment is available to be spent
     Spendable,
     /// The payment is not spentable and will not be part of the balance
@@ -26,26 +26,43 @@ pub enum Status {
     Spent,
 }
 
-impl From<Status> for u32 {
-    fn from(val: Status) -> Self {
+/// Serializes an object to bytes using the default serialization method
+pub fn to_bytes<T>(val: &T) -> Result<Vec<u8>, Error>
+where
+    T: serde::Serialize + borsh::BorshSerialize,
+{
+    borsh::to_vec(val).map_err(|e| Error::Encoding(e.to_string()))
+}
+
+/// Deserializes an object from bytes using the default deserialization method
+pub fn from_bytes<T>(val: &[u8]) -> Result<T, Error>
+where
+    T: serde::de::DeserializeOwned + borsh::BorshDeserialize,
+{
+    borsh::BorshDeserialize::deserialize(&mut val.as_ref())
+        .map_err(|e| Error::Encoding(e.to_string()))
+}
+
+impl From<ReceivedPaymentStatus> for u32 {
+    fn from(val: ReceivedPaymentStatus) -> Self {
         match val {
-            Status::Spendable => 0,
-            Status::Locked => 20,
-            Status::Spent => 30,
-            Status::Failed => 40,
+            ReceivedPaymentStatus::Spendable => 0,
+            ReceivedPaymentStatus::Locked => 20,
+            ReceivedPaymentStatus::Spent => 30,
+            ReceivedPaymentStatus::Failed => 40,
         }
     }
 }
 
-impl TryFrom<u32> for Status {
+impl TryFrom<u32> for ReceivedPaymentStatus {
     type Error = Error;
 
     fn try_from(value: u32) -> Result<Self, Self::Error> {
         match value {
-            0 => Ok(Status::Spendable),
-            20 => Ok(Status::Locked),
-            30 => Ok(Status::Spent),
-            40 => Ok(Status::Failed),
+            0 => Ok(ReceivedPaymentStatus::Spendable),
+            20 => Ok(ReceivedPaymentStatus::Locked),
+            30 => Ok(ReceivedPaymentStatus::Spent),
+            40 => Ok(ReceivedPaymentStatus::Failed),
             _ => Err(Error::Storage(format!("Invalid status: {}", value))),
         }
     }
@@ -108,20 +125,12 @@ pub trait Batch<'a> {
     /// The batch is commited into the storage layer and it is consumed.
     async fn commit(self) -> Result<(), Error>;
 
-    /// Returns a transaction from the batch's point of view, giving the ability to lock the
-    /// resource to update it. The lock should be released when the transaction is dropped or
-    /// committed.
-    async fn get_and_lock_transaction(
-        &mut self,
-        transaction_id: &TxId,
-    ) -> Result<Transaction, Error>;
-
     /// Flag the given payments as spent by the given transaction.
     async fn spend_payments(
         &mut self,
         transaction_id: &TxId,
         spends: Vec<PaymentId>,
-        status: Status,
+        status: ReceivedPaymentStatus,
     ) -> Result<(), Error>;
 
     /// Create a new list of payments
@@ -129,7 +138,7 @@ pub trait Batch<'a> {
         &mut self,
         transaction_id: &TxId,
         recipients: &[PaymentTo],
-        status: Status,
+        status: ReceivedPaymentStatus,
     ) -> Result<(), Error>;
 
     /// Updates all payments related to a transaction
@@ -142,21 +151,43 @@ pub trait Batch<'a> {
     async fn update_transaction_payments(
         &mut self,
         transaction_id: &TxId,
-        create_status: Status,
-        spend_status: Status,
+        create_status: ReceivedPaymentStatus,
+        spend_status: ReceivedPaymentStatus,
     ) -> Result<(usize, usize), Error>;
 
     /// Returns the stats of a payment from the point of view of the on-going transaction
-    async fn get_payment_status(&mut self, transaction_id: &TxId) -> Result<Option<Status>, Error>;
+    async fn get_payment_status(
+        &mut self,
+        transaction_id: &TxId,
+    ) -> Result<Option<ReceivedPaymentStatus>, Error>;
 
     /// Stores a transaction
-    async fn store_transaction(&mut self, transaction: &Transaction) -> Result<(), Error>;
+    async fn store_base_transaction(
+        &mut self,
+        transaction_id: &TxId,
+        transaction: &BaseTx,
+    ) -> Result<(), Error>;
+
+    /// Persists a revision
+    async fn store_revision(
+        &mut self,
+        revision_id: &RevId,
+        revision: &Revision,
+    ) -> Result<(), Error>;
+
+    /// Updates the revision of a transaction. Both the revision and the transaction must exist.
+    async fn update_transaction_revision(
+        &mut self,
+        transaction_id: &TxId,
+        revision_id: &RevId,
+        previous_rev_id: Option<&RevId>,
+    ) -> Result<(), Error>;
 
     /// Sets the tags for a given transaction. Any tag not included in this
     /// vector should be removed
     async fn tag_transaction(
         &mut self,
-        transaction: &Transaction,
+        transaction_id: &TxId,
         tags: &[String],
     ) -> Result<(), Error>;
 
@@ -224,7 +255,7 @@ pub trait Storage {
     ) -> Result<Vec<(TxId, String, DateTime<Utc>)>, Error>;
     */
 
-    /// Returns a transaction object by id
+    /// Returns a revision with a transaction object by id
     async fn get_transaction(&self, transaction_id: &TxId) -> Result<Transaction, Error>;
 
     /// Returns a list of a transactions for a given account (and optionally
@@ -241,7 +272,7 @@ pub trait Storage {
 #[cfg(test)]
 pub mod test {
     use super::*;
-    use crate::{config::Config, status::StatusManager};
+    use crate::{config::Config, status::StatusManager, Transaction};
     use rand::Rng;
 
     #[macro_export]
@@ -323,14 +354,44 @@ pub mod test {
         )
         .expect("valid tx");
         let mut storing = storage.begin().await.expect("valid tx");
-        storing.store_transaction(&deposit).await.expect("store tx");
+        storing
+            .store_base_transaction(&deposit.id, &deposit.transaction)
+            .await
+            .expect("store tx");
+        storing
+            .store_revision(&deposit.revision_id, &deposit.revision)
+            .await
+            .expect("store revision");
+        storing
+            .update_transaction_revision(
+                &deposit.id,
+                &deposit.revision_id,
+                deposit.revision.previous.as_ref(),
+            )
+            .await
+            .expect("update tx");
         storing.rollback().await.expect("rollback");
-        assert!(storage.get_transaction(deposit.id()).await.is_err());
+        assert!(storage.get_transaction(&deposit.id).await.is_err());
 
         let mut storing = storage.begin().await.expect("valid tx");
-        storing.store_transaction(&deposit).await.expect("store tx");
+        storing
+            .store_base_transaction(&deposit.id, &deposit.transaction)
+            .await
+            .expect("store tx");
+        storing
+            .store_revision(&deposit.revision_id, &deposit.revision)
+            .await
+            .expect("store revision");
+        storing
+            .update_transaction_revision(
+                &deposit.id,
+                &deposit.revision_id,
+                deposit.revision.previous.as_ref(),
+            )
+            .await
+            .expect("update tx");
         storing.commit().await.expect("commit");
-        assert!(storage.get_transaction(deposit.id()).await.is_ok());
+        assert!(storage.get_transaction(&deposit.id).await.is_ok());
     }
 
     pub async fn transaction_not_available_until_commit<T>(storage: T)
@@ -348,15 +409,45 @@ pub mod test {
         )
         .expect("valid tx");
         let mut storing = storage.begin().await.expect("valid tx");
-        storing.store_transaction(&deposit).await.expect("store tx");
-        assert!(storage.get_transaction(deposit.id()).await.is_err());
+        storing
+            .store_base_transaction(&deposit.id, &deposit.transaction)
+            .await
+            .expect("store tx");
+        storing
+            .store_revision(&deposit.revision_id, &deposit.revision)
+            .await
+            .expect("store revision");
+        storing
+            .update_transaction_revision(
+                &deposit.id,
+                &deposit.revision_id,
+                deposit.revision.previous.as_ref(),
+            )
+            .await
+            .expect("update tx");
+        assert!(storage.get_transaction(&deposit.id).await.is_err());
         storing.rollback().await.expect("rollback");
-        assert!(storage.get_transaction(deposit.id()).await.is_err());
+        assert!(storage.get_transaction(&deposit.id).await.is_err());
 
         let mut storing = storage.begin().await.expect("valid tx");
-        storing.store_transaction(&deposit).await.expect("store tx");
+        storing
+            .store_base_transaction(&deposit.id, &deposit.transaction)
+            .await
+            .expect("store base tx");
+        storing
+            .store_revision(&deposit.revision_id, &deposit.revision)
+            .await
+            .expect("store revision");
+        storing
+            .update_transaction_revision(
+                &deposit.id,
+                &deposit.revision_id,
+                deposit.revision.previous.as_ref(),
+            )
+            .await
+            .expect("update tx");
         storing.commit().await.expect("commit");
-        assert!(storage.get_transaction(deposit.id()).await.is_ok());
+        assert!(storage.get_transaction(&deposit.id).await.is_ok());
     }
 
     pub async fn does_not_update_spent_payments<T>(storage: T)
@@ -381,14 +472,18 @@ pub mod test {
         let recipients = vec![recipient];
 
         writer
-            .create_payments(&transaction_id, &recipients, Status::Locked)
+            .create_payments(&transaction_id, &recipients, ReceivedPaymentStatus::Locked)
             .await
             .expect("valid payment");
 
         // Alter state
         assert_eq!(
             writer
-                .update_transaction_payments(&transaction_id, Status::Locked, Status::Locked)
+                .update_transaction_payments(
+                    &transaction_id,
+                    ReceivedPaymentStatus::Locked,
+                    ReceivedPaymentStatus::Locked
+                )
                 .await
                 .expect("valid"),
             (1, 0)
@@ -397,13 +492,20 @@ pub mod test {
         // Transactions is settled and their spent payments are forever spent
         assert_eq!(
             writer
-                .update_transaction_payments(&transaction_id, Status::Spent, Status::Spent)
+                .update_transaction_payments(
+                    &transaction_id,
+                    ReceivedPaymentStatus::Spent,
+                    ReceivedPaymentStatus::Spent
+                )
                 .await
                 .expect("valid"),
             (1, 0)
         );
 
-        for status in [Status::Failed, Status::Spendable] {
+        for status in [
+            ReceivedPaymentStatus::Failed,
+            ReceivedPaymentStatus::Spendable,
+        ] {
             assert_eq!(
                 writer
                     .update_transaction_payments(&transaction_id, status, status)
@@ -428,7 +530,13 @@ pub mod test {
             .from_human(&format!("{}", rng.gen_range(-1000.0..1000.0)))
             .expect("valid amount");
 
-        for (i, status) in [Status::Locked, Status::Spendable].into_iter().enumerate() {
+        for (i, status) in [
+            ReceivedPaymentStatus::Locked,
+            ReceivedPaymentStatus::Spendable,
+        ]
+        .into_iter()
+        .enumerate()
+        {
             let transaction_id: TxId = vec![i as u8; 32].try_into().expect("valid tx id");
 
             writer
@@ -443,7 +551,9 @@ pub mod test {
                 .await
                 .expect("valid payment");
 
-            for (spend_new_status, create_new_status) in [(Status::Spent, Status::Spent)] {
+            for (spend_new_status, create_new_status) in
+                [(ReceivedPaymentStatus::Spent, ReceivedPaymentStatus::Spent)]
+            {
                 assert_eq!(
                     writer
                         .update_transaction_payments(
@@ -471,7 +581,10 @@ pub mod test {
             .from_human(&format!("{}", rng.gen_range(-1000.0..1000.0)))
             .expect("valid amount");
 
-        for (i, status) in [Status::Failed, Status::Spent].into_iter().enumerate() {
+        for (i, status) in [ReceivedPaymentStatus::Failed, ReceivedPaymentStatus::Spent]
+            .into_iter()
+            .enumerate()
+        {
             let transaction_id: TxId = vec![i as u8; 32].try_into().expect("valid tx id");
 
             writer
@@ -487,8 +600,11 @@ pub mod test {
                 .expect("valid payment");
 
             for (spend_new_status, create_new_status) in [
-                (Status::Spent, Status::Spent),
-                (Status::Spendable, Status::Spendable),
+                (ReceivedPaymentStatus::Spent, ReceivedPaymentStatus::Spent),
+                (
+                    ReceivedPaymentStatus::Spendable,
+                    ReceivedPaymentStatus::Spendable,
+                ),
             ] {
                 assert_eq!(
                     writer
@@ -533,7 +649,11 @@ pub mod test {
                 .collect::<Vec<_>>();
 
             writer
-                .create_payments(&transaction_id, &recipients, Status::Spendable)
+                .create_payments(
+                    &transaction_id,
+                    &recipients,
+                    ReceivedPaymentStatus::Spendable,
+                )
                 .await
                 .expect("valid payment");
         }
@@ -584,7 +704,22 @@ pub mod test {
         .expect("valid tx");
 
         let mut batch = storage.begin().await.expect("valid tx");
-        batch.store_transaction(&deposit).await.expect("is ok");
+        batch
+            .store_base_transaction(&deposit.id, &deposit.transaction)
+            .await
+            .expect("is ok");
+        batch
+            .store_revision(&deposit.revision_id, &deposit.revision)
+            .await
+            .expect("store revision");
+        batch
+            .update_transaction_revision(
+                &deposit.id,
+                &deposit.revision_id,
+                deposit.revision.previous.as_ref(),
+            )
+            .await
+            .expect("update tx");
         batch
             .relate_account_to_transaction(&deposit.id, &account1, Type::Deposit)
             .await
@@ -653,7 +788,7 @@ pub mod test {
                     to: account.clone(),
                     amount,
                 }],
-                Status::Locked,
+                ReceivedPaymentStatus::Locked,
             )
             .await
             .expect("valid payment");

utxo/src/storage/sqlite/batch.rs

@@ -1,8 +1,7 @@
 use crate::{
     payment::PaymentTo,
-    storage::{self, Error, Status},
-    transaction::inner::Revision,
-    AccountId, PaymentId, RevId, Transaction, TxId, Type,
+    storage::{self, to_bytes, Error, ReceivedPaymentStatus},
+    AccountId, BaseTx, PaymentId, RevId, Revision, TxId, Type,
 };
 use sqlx::{Row, Sqlite, Transaction as SqlxTransaction};
 use std::{marker::PhantomData, num::TryFromIntError};
@@ -56,43 +55,6 @@ impl<'a> storage::Batch<'a> for Batch<'a> {
         Ok(())
     }
 
-    async fn get_and_lock_transaction(
-        &mut self,
-        transaction_id: &TxId,
-    ) -> Result<Transaction, Error> {
-        let row = sqlx::query(
-            r#"
-           SELECT
-                "t"."revision_id" as "current_id",
-                "b"."blob"
-            FROM
-                "transactions" as "t",
-                "revisions" as "b"
-            WHERE
-                "t"."transaction_id" = ?
-                AND "t"."revision_id" = "b"."revision_id"
-                "#,
-        )
-        .bind(transaction_id.to_string())
-        .fetch_one(&mut *self.inner)
-        .await
-        .map_err(|e| Error::Storage(e.to_string()))?;
-
-        let encoded = row
-            .try_get::<Vec<u8>, usize>(1)
-            .map_err(|e| Error::Storage(e.to_string()))?;
-        Transaction::from_revision(
-            Revision::from_slice(&encoded)?,
-            Some(
-                row.try_get::<String, usize>(0)
-                    .map_err(|e| Error::Storage(e.to_string()))?
-                    .parse::<RevId>()
-                    .map_err(|e| Error::Storage(e.to_string()))?,
-            ),
-        )
-        .map_err(|e| Error::Encoding(e.to_string()))
-    }
-
     async fn commit(self) -> Result<(), Error> {
         self.inner
             .commit()
@@ -104,7 +66,7 @@ impl<'a> storage::Batch<'a> for Batch<'a> {
         &mut self,
         transaction_id: &TxId,
         spends: Vec<PaymentId>,
-        status: Status,
+        status: ReceivedPaymentStatus,
     ) -> Result<(), Error> {
         let spend_ids = spends.iter().map(|id| id.to_string()).collect::<Vec<_>>();
         let placeholder = format!("?{}", ", ?".repeat(spend_ids.len()));
@@ -146,7 +108,7 @@ impl<'a> storage::Batch<'a> for Batch<'a> {
         &mut self,
         transaction_id: &TxId,
         recipients: &[PaymentTo],
-        status: Status,
+        status: ReceivedPaymentStatus,
     ) -> Result<(), Error> {
         for (pos, recipient) in recipients.iter().enumerate() {
             sqlx::query(
@@ -179,8 +141,8 @@ impl<'a> storage::Batch<'a> for Batch<'a> {
     async fn update_transaction_payments(
         &mut self,
         transaction_id: &TxId,
-        create_status: Status,
-        spend_status: Status,
+        create_status: ReceivedPaymentStatus,
+        spend_status: ReceivedPaymentStatus,
     ) -> Result<(usize, usize), Error> {
         let creates = sqlx::query(
             r#"
@@ -191,8 +153,8 @@ impl<'a> storage::Batch<'a> for Batch<'a> {
         )
         .bind::<u32>(create_status.into())
         .bind(format!("{}:%", transaction_id))
-        .bind::<u32>(Status::Spendable.into())
-        .bind::<u32>(Status::Locked.into())
+        .bind::<u32>(ReceivedPaymentStatus::Spendable.into())
+        .bind::<u32>(ReceivedPaymentStatus::Locked.into())
         .execute(&mut *self.inner)
         .await
         .map_err(|e| Error::Storage(e.to_string()))?;
@@ -205,14 +167,14 @@ impl<'a> storage::Batch<'a> for Batch<'a> {
             "#,
         )
         .bind::<u32>(spend_status.into())
-        .bind(if spend_status == Status::Spendable {
+        .bind(if spend_status == ReceivedPaymentStatus::Spendable {
             None
         } else {
             Some(transaction_id.to_string())
         })
         .bind(transaction_id.to_string())
-        .bind::<u32>(Status::Spendable.into())
-        .bind::<u32>(Status::Locked.into())
+        .bind::<u32>(ReceivedPaymentStatus::Spendable.into())
+        .bind::<u32>(ReceivedPaymentStatus::Locked.into())
         .execute(&mut *self.inner)
         .await
         .map_err(|e| Error::Storage(e.to_string()))?;
@@ -223,7 +185,10 @@ impl<'a> storage::Batch<'a> for Batch<'a> {
         ))
     }
 
-    async fn get_payment_status(&mut self, transaction_id: &TxId) -> Result<Option<Status>, Error> {
+    async fn get_payment_status(
+        &mut self,
+        transaction_id: &TxId,
+    ) -> Result<Option<ReceivedPaymentStatus>, Error> {
         let row = sqlx::query(
             r#"
             SELECT
@@ -254,61 +219,95 @@ impl<'a> storage::Batch<'a> for Batch<'a> {
         }
     }
 
-    async fn store_transaction(&mut self, transaction: &Transaction) -> Result<(), Error> {
+    async fn store_base_transaction(
+        &mut self,
+        transaction_id: &TxId,
+        transaction: &BaseTx,
+    ) -> Result<(), Error> {
         sqlx::query(
             r#"
-                INSERT INTO "revisions"("revision_id", "transaction_id", "blob", "status", "created_at")
-                VALUES(?, ?, ?, ?, ?)
+                INSERT INTO "base_transactions"("transaction_id", "type", "blob")
+                VALUES(?, ?, ?)
             "#,
         )
-        .bind(transaction.revision_id.to_string())
-        .bind(transaction.id.to_string())
-        .bind(transaction.revision().to_vec()?)
-        .bind(transaction.status().to_string())
-        .bind(transaction.created_at())
+        .bind(transaction_id.to_string())
+        .bind::<u32>(transaction.typ.into())
+        .bind(to_bytes(&transaction)?)
         .execute(&mut *self.inner)
         .await
         .map_err(|e| Error::Storage(e.to_string()))?;
 
-        if let Some(previous) = transaction.previous() {
-            let r = sqlx::query(
+        Ok(())
+    }
+
+    async fn update_transaction_revision(
+        &mut self,
+        transaction_id: &TxId,
+        revision_id: &RevId,
+        last_rev_id: Option<&RevId>,
+    ) -> Result<(), Error> {
+        let r = if let Some(last_rev_id) = last_rev_id {
+            sqlx::query(
                 r#"
-                UPDATE "transactions" SET "revision_id" = ?, "status" = ?
-                WHERE "transaction_id" = ? and "revision_id" = ?
-                "#,
+            UPDATE "transactions"
+            SET "previous_revision_id" = ?, "revision_id" = ?
+            WHERE "transaction_id" = ? AND "revision_id" = ?
+            "#,
             )
-            .bind(transaction.revision_id.to_string())
-            .bind(transaction.status().to_string())
-            .bind(transaction.id.to_string())
-            .bind(previous.to_string())
-            .execute(&mut *self.inner)
-            .await
-            .map_err(|e| Error::Storage(e.to_string()))?;
-
-            if r.rows_affected() == 0 {
-                return Err(Error::NoUpdate);
-            }
+            .bind(last_rev_id.to_string())
+            .bind(revision_id.to_string())
+            .bind(transaction_id.to_string())
+            .bind(last_rev_id.to_string())
         } else {
             sqlx::query(
                 r#"
-                INSERT INTO "transactions"("transaction_id", "revision_id", "status")
-                VALUES(?, ?, ?)
-            "#,
+            INSERT INTO "transactions"("transaction_id", "revision_id", "status")
+            VALUES(?, ?, "")
+                "#,
             )
-            .bind(transaction.id.to_string())
-            .bind(transaction.revision_id.to_string())
-            .bind(transaction.status().to_string())
-            .execute(&mut *self.inner)
-            .await
-            .map_err(|e| Error::Storage(e.to_string()))?;
+            .bind(transaction_id.to_string())
+            .bind(revision_id.to_string())
         }
+        .execute(&mut *self.inner)
+        .await
+        .map_err(|e| Error::Storage(e.to_string()))?;
+        if r.rows_affected() == 0 {
+            Err(Error::NoUpdate)
+        } else {
+            Ok(())
+        }
+    }
+
+    async fn store_revision(
+        &mut self,
+        revision_id: &RevId,
+        revision: &Revision,
+    ) -> Result<(), Error> {
+        sqlx::query(
+            r#"
+            INSERT INTO "revisions"("revision_id", "blob", "transaction_id", "previous_revision_id", "status")
+            VALUES(?, ?, ?, ?, ?)
+        "#,
+        )
+        .bind(revision_id.to_string())
+        .bind(to_bytes(revision)?)
+        .bind(revision.transaction_id().to_string())
+        .bind(if let Some(prev_id) = revision.previous_revision_id() {
+            Some(prev_id.to_string())
+        } else {
+            None
+        })
+        .bind(revision.status.to_string())
+        .execute(&mut *self.inner)
+        .await
+        .map_err(|e| Error::Storage(e.to_string()))?;
 
         Ok(())
     }
 
     async fn tag_transaction(
         &mut self,
-        _transaction: &Transaction,
+        _transaction_id: &TxId,
         _tags: &[String],
     ) -> Result<(), Error> {
         todo!()

utxo/src/storage/sqlite/mod.rs

@@ -2,9 +2,10 @@
 use crate::{
     amount::AmountCents,
     storage::{Error, Storage},
-    transaction::{inner::Revision, Type},
-    AccountId, Amount, Asset, PaymentFrom, PaymentId, RevId, Transaction, TxId,
+    transaction::{Revision, Type},
+    AccountId, Amount, Asset, BaseTx, PaymentFrom, PaymentId, Transaction, TxId,
 };
+use borsh::from_slice;
 use futures::TryStreamExt;
 use sqlx::{sqlite::SqliteRow, Executor, Row};
 use std::collections::HashMap;
@@ -14,7 +15,7 @@ mod batch;
 pub use batch::Batch;
 pub use sqlx::sqlite::{SqliteConnectOptions, SqlitePoolOptions};
 
-use super::Status;
+use super::ReceivedPaymentStatus;
 
 /// SQLite storage layer for Verax
 pub struct SQLite {
@@ -37,15 +38,23 @@ impl SQLite {
             r#"
         CREATE TABLE IF NOT EXISTS "transactions" (
             "transaction_id" VARCHAR(67) NOT NULL PRIMARY KEY,
-            "revision_id" VARCHAR(68) NOT NULL,
-            "status" VARCHAR(10) NOT NULL,
+            "previous_revision_id" VARCHAR(68) DEFAULT NULL,
+            "revision_id" VARCHAR(68) DEFAULT NULL,
+            "status" VARCHAR(30) NOT NULL,
+            "created_at" DATETIME DEFAULT CURRENT_TIMESTAMP,
+            "updated_at" DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
+        CREATE TABLE IF NOT EXISTS "base_transactions" (
+            "transaction_id" VARCHAR(67) NOT NULL PRIMARY KEY,
+            "type" INTEGER NOT NULL,
+            "blob" BINARY NOT NULL,
             "created_at" DATETIME DEFAULT CURRENT_TIMESTAMP,
             "updated_at" DATETIME DEFAULT CURRENT_TIMESTAMP
         );
         CREATE TABLE IF NOT EXISTS "revisions" (
             "revision_id" VARCHAR(68) NOT NULL PRIMARY KEY,
             "transaction_id" VARCHAR(67) NOT NULL,
-            "previous_blob_id" BLOB,
+            "previous_revision_id" VARCHAR(68) DEFAULT NULL,
             "status" VARCHAR(30) NOT NULL,
             "blob" BINARY NOT NULL,
             "created_at" DATETIME DEFAULT CURRENT_TIMESTAMP
@@ -117,6 +126,7 @@ impl Storage for SQLite {
             .map_err(|x| Error::Storage(x.to_string()))
     }
 
+    #[allow(warnings)]
     async fn get_balance(&self, account: &AccountId) -> Result<Vec<Amount>, Error> {
         let mut conn = self
             .db
@@ -139,7 +149,7 @@ impl Storage for SQLite {
             "#,
         )
         .bind(account.to_string())
-        .bind::<u32>(Status::Spendable.into())
+        .bind::<u32>(ReceivedPaymentStatus::Spendable.into())
         .fetch(&mut *conn);
 
         let mut balances = HashMap::<Asset, Amount>::new();
@@ -201,7 +211,7 @@ impl Storage for SQLite {
         )
         .bind(account.to_string())
         .bind(asset.to_string())
-        .bind::<u32>(Status::Spendable.into())
+        .bind::<u32>(ReceivedPaymentStatus::Spendable.into())
         .fetch_all(&mut *conn)
         .await
         .map_err(|e| Error::Storage(e.to_string()))?;
@@ -244,13 +254,16 @@ impl Storage for SQLite {
             r#"
             SELECT
                 "t"."revision_id" as "current_id",
+                "bt"."blob",
                 "b"."blob"
             FROM
                 "transactions" as "t",
+                "base_transactions" as "bt",
                 "revisions" as "b"
             WHERE
                 "t"."transaction_id" = ?
                 AND "t"."revision_id" = "b"."revision_id"
+                AND "t"."transaction_id" = "bt"."transaction_id"
         "#,
         )
         .bind(transaction_id.to_string())
@@ -258,20 +271,20 @@ impl Storage for SQLite {
         .await
         .map_err(|e| Error::Storage(e.to_string()))?;
 
-        let encoded = row
+        let transaction = row
             .try_get::<Vec<u8>, usize>(1)
             .map_err(|e| Error::Storage(e.to_string()))?;
 
-        Transaction::from_revision(
-            Revision::from_slice(&encoded)?,
-            Some(
-                row.try_get::<String, usize>(0)
-                    .map_err(|e| Error::Storage(e.to_string()))?
-                    .parse::<RevId>()
-                    .map_err(|e| Error::Storage(e.to_string()))?,
-            ),
+        let revision = row
+            .try_get::<Vec<u8>, usize>(2)
+            .map_err(|e| Error::Storage(e.to_string()))?;
+
+        (
+            from_slice::<BaseTx>(&transaction)?,
+            from_slice::<Revision>(&revision)?,
         )
-        .map_err(|e| Error::Encoding(e.to_string()))
+            .try_into()
+            .map_err(|e: crate::transaction::Error| Error::Encoding(e.to_string()))
     }
 
     async fn get_transactions(
@@ -290,15 +303,18 @@ impl Storage for SQLite {
             r#"SELECT
                 "t"."transaction_id",
                 "t"."revision_id",
+                "bt"."blob",
                 "b"."blob"
             FROM
                 "transaction_accounts" as "ta",
+                "base_transactions" as "bt",
                 "transactions" as "t",
                 "revisions" as "b"
             WHERE
                 "ta"."account_id" = ?
                 AND "t"."transaction_id" = "ta"."transaction_id"
                 AND "t"."revision_id" = "b"."revision_id"
+                AND "t"."transaction_id" = "bt"."transaction_id"
             ORDER BY "ta"."id" DESC"#
                 .to_owned()
         } else {
@@ -310,16 +326,20 @@ impl Storage for SQLite {
             format!(
                 r#"SELECT
                     "t"."transaction_id",
+                    "t"."revision_id",
+                    "bt"."blob",
                     "b"."blob"
                 FROM
                     "transaction_accounts" as "ta",
+                    "base_transactions" as "bt",
                     "transactions" as "t",
                     "revisions" as "b"
                 WHERE
                     "account_id" = ?
                     AND "t"."transaction_id" = "ta"."transaction_id"
                     AND "t"."revision_id" = "b"."revision_id"
-                    AND "type" IN ({types})
+                    AND "t"."transaction_id" = "bt"."transaction_id"
+                    AND "ta"."type" IN ({types})
                 ORDER BY "ta"."id" DESC"#,
             )
         };
@@ -331,20 +351,20 @@ impl Storage for SQLite {
             .map_err(|e| Error::Storage(e.to_string()))?
             .into_iter()
             .map(|row| {
-                let encoded = row
-                    .try_get::<Vec<u8>, usize>(1)
+                let base_tx = row
+                    .try_get::<Vec<u8>, usize>(2)
+                    .map_err(|e| Error::Storage(e.to_string()))?;
+
+                let revision = row
+                    .try_get::<Vec<u8>, usize>(3)
                     .map_err(|e| Error::Storage(e.to_string()))?;
 
-                Transaction::from_revision(
-                    Revision::from_slice(&encoded)?,
-                    Some(
-                        row.try_get::<String, usize>(0)
-                            .map_err(|e| Error::Storage(e.to_string()))?
-                            .parse::<RevId>()
-                            .map_err(|e| Error::Storage(e.to_string()))?,
-                    ),
+                (
+                    from_slice::<BaseTx>(&base_tx)?,
+                    from_slice::<Revision>(&revision)?,
                 )
-                .map_err(|e| Error::Encoding(e.to_string()))
+                    .try_into()
+                    .map_err(|e: crate::transaction::Error| Error::Encoding(e.to_string()))
             })
             .collect::<Result<Vec<Transaction>, Error>>()
     }

utxo/src/transaction/base_tx.rs

@@ -0,0 +1,159 @@
+use crate::{
+    amount::AmountCents,
+    payment::PaymentTo,
+    storage::to_bytes,
+    transaction::{Error, Revision, Type},
+    AccountId, Asset, PaymentFrom, Status, TxId,
+};
+use chrono::{serde::ts_milliseconds, DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+use std::collections::HashMap;
+
+#[derive(Debug, Clone, Deserialize, Serialize, borsh::BorshSerialize, borsh::BorshDeserialize)]
+/// Transaction struct
+///
+/// A transaction is an immutable object that represents a financial operation. It contains a list
+/// of payments that are spent and a list of payments that are created. The sum of the payments
+/// spent must be equal to the sum of the payments created, unless the transaction is a Deposit or
+/// Withdrawal transaction.
+pub struct BaseTx {
+    /// List of spend payments to create this transaction
+    pub spends: Vec<PaymentFrom>,
+    /// New payments that are created by this transaction
+    pub creates: Vec<PaymentTo>,
+    /// Transaction type
+    #[serde(rename = "type")]
+    pub typ: Type,
+    /// Human-readable reference to this transaction
+    pub reference: String,
+    #[serde(rename = "created_at", with = "ts_milliseconds")]
+    #[borsh(
+        serialize_with = "super::to_ts_microseconds",
+        deserialize_with = "super::from_ts_microseconds"
+    )]
+    /// Timestamp when this transaction has been created
+    pub created_at: DateTime<Utc>,
+}
+
+#[allow(dead_code)]
+/// Transaction object
+impl BaseTx {
+    /// Creates a new instance
+    pub fn new(
+        spends: Vec<PaymentFrom>,
+        creates: Vec<PaymentTo>,
+        reference: String,
+        typ: Type,
+        status: Status,
+    ) -> Result<(Self, Revision), Error> {
+        let new = Self {
+            spends,
+            creates,
+            reference,
+            typ,
+            created_at: Utc::now(),
+        };
+        let id = new.id()?;
+        Ok((new, Revision::new(id, None, "".to_owned(), vec![], status)))
+    }
+
+    /// Calculates the transaction ID
+    pub fn id(&self) -> Result<TxId, Error> {
+        let mut hasher = Sha256::new();
+        hasher.update(to_bytes(&self)?);
+        Ok(TxId::new(hasher.finalize().into()))
+    }
+
+    /// Validates the transaction input and output (debit and credit)
+    ///
+    /// The total sum of debits and credits should always be zero in transactions, unless they are
+    /// deposits or withdrawals.
+    ///
+    /// Negative amounts can be used in transactions, but the total sum of debits and credits should
+    /// always be zero, and the debit amount should be positive numbers
+    pub fn validate(&self) -> Result<(), Error> {
+        let mut debit = HashMap::<Asset, AmountCents>::new();
+        let mut credit = HashMap::<Asset, AmountCents>::new();
+
+        for input in self.spends.iter() {
+            if let Some(value) = debit.get_mut(input.amount.asset()) {
+                *value = input
+                    .amount
+                    .cents()
+                    .checked_add(*value)
+                    .ok_or(Error::Overflow)?;
+            } else {
+                debit.insert(input.amount.asset().clone(), input.amount.cents());
+            }
+        }
+
+        for (asset, amount) in debit.iter() {
+            if *amount <= 0 {
+                return Err(Error::InvalidAmount(
+                    asset.new_amount(*amount),
+                    asset.new_amount(*amount),
+                ));
+            }
+        }
+
+        if !self.typ.is_transaction() {
+            // We don't care input/output balance in external operations
+            // (withdrawals/deposits), because these operations are inbalanced
+            return Ok(());
+        }
+
+        for output in self.creates.iter() {
+            if let Some(value) = credit.get_mut(output.amount.asset()) {
+                *value = output
+                    .amount
+                    .cents()
+                    .checked_add(*value)
+                    .ok_or(Error::Overflow)?;
+            } else {
+                credit.insert(output.amount.asset().clone(), output.amount.cents());
+            }
+        }
+
+        for (asset, credit_amount) in credit.into_iter() {
+            if let Some(debit_amount) = debit.remove(&asset) {
+                if debit_amount != credit_amount {
+                    return Err(Error::InvalidAmount(
+                        asset.new_amount(debit_amount),
+                        asset.new_amount(credit_amount),
+                    ));
+                }
+            } else {
+                return Err(Error::MissingSpendingAsset(asset));
+            }
+        }
+
+        if let Some((asset, _)) = debit.into_iter().next() {
+            return Err(Error::MissingPaymentAsset(asset));
+        }
+
+        Ok(())
+    }
+
+    /// Returns a unique list of accounts involved in this transaction.
+    ///
+    /// Accounts are sorted and unique, and they include the accounts that spent and that receives
+    pub fn accounts(&self) -> Vec<AccountId> {
+        let mut accounts = self
+            .creates
+            .iter()
+            .map(|x| x.to.clone())
+            .collect::<Vec<_>>();
+
+        accounts.extend(
+            self.spends
+                .iter()
+                .map(|x| x.from.clone())
+                .collect::<Vec<_>>(),
+        );
+
+        accounts.sort();
+        accounts.dedup();
+        accounts
+    }
+}

utxo/src/transaction/error.rs

@@ -1,4 +1,4 @@
-use crate::{status, storage, Amount, Asset, Status, TxId};
+use crate::{status, storage, Amount, Asset, RevId, Status, TxId};
 use serde::Serialize;
 
 #[derive(thiserror::Error, Debug, Serialize)]
@@ -44,6 +44,9 @@ pub enum Error {
     #[error("Invalid calculated id {0} (expected {1})")]
     InvalidTxId(TxId, TxId),
 
+    #[error("Invalid calculated rev-id {0} (expected {1})")]
+    InvalidRevId(RevId, RevId),
+
     #[error("Overflow")]
     Overflow,
 }

utxo/src/transaction/inner.rs

@@ -1,532 +0,0 @@
-use crate::{
-    amount::AmountCents,
-    config::Config,
-    payment::PaymentTo,
-    storage::{self, Batch, Storage},
-    transaction::*,
-    AccountId, Amount, Asset, PaymentFrom, RevId, Status, TxId,
-};
-use chrono::{serde::ts_milliseconds, DateTime, TimeZone, Utc};
-use serde::{Deserialize, Serialize};
-use sha2::{Digest, Sha256};
-use std::collections::HashMap;
-
-/// Transaction Inner
-///
-/// This is the transaction details, as described bellow, it is a Transaction but without the ID nor
-/// the revision ID.
-///
-/// This seperated struct is used to calculate the ID of the transaction, and to be able to
-/// serialize the transaction without the ID.
-///
-/// Since the transaction ID is calculated from the transaction itself, to provide cryptographic
-/// security that its content was not altered.
-#[derive(Debug, Clone, Deserialize, Serialize, borsh::BorshSerialize, borsh::BorshDeserialize)]
-pub struct Revision {
-    #[serde(rename = "_prev_rev")]
-    /// Any previous transaction that this transaction is replacing.
-    previous: Option<RevId>,
-    /// A human-readable description of the transaction changes.
-    changelog: String,
-    spends: Vec<PaymentFrom>,
-    creates: Vec<PaymentTo>,
-    #[allow(dead_code)]
-    reference: String,
-    #[serde(rename = "type")]
-    typ: Type,
-    status: Status,
-    tags: Vec<String>,
-    #[serde(with = "ts_milliseconds")]
-    #[borsh(
-        serialize_with = "to_ts_microseconds",
-        deserialize_with = "from_ts_microseconds"
-    )]
-    created_at: DateTime<Utc>,
-    #[serde(with = "ts_milliseconds")]
-    #[borsh(
-        serialize_with = "to_ts_microseconds",
-        deserialize_with = "from_ts_microseconds"
-    )]
-    updated_at: DateTime<Utc>,
-}
-
-fn to_ts_microseconds<W: std::io::Write>(
-    dt: &DateTime<Utc>,
-    writer: &mut W,
-) -> std::io::Result<()> {
-    borsh::BorshSerialize::serialize(&dt.timestamp_millis(), writer)?;
-    Ok(())
-}
-
-fn from_ts_microseconds<R: borsh::io::Read>(
-    reader: &mut R,
-) -> ::core::result::Result<DateTime<Utc>, borsh::io::Error> {
-    match Utc.timestamp_millis_opt(borsh::BorshDeserialize::deserialize_reader(reader)?) {
-        chrono::LocalResult::Single(dt) => Ok(dt.with_timezone(&Utc)),
-        _ => Err(borsh::io::Error::new(
-            borsh::io::ErrorKind::InvalidData,
-            "invalid timestamp".to_owned(),
-        )),
-    }
-}
-
-impl Revision {
-    /// Calculates a revision ID
-    pub fn calculate_rev_id(&self) -> Result<RevId, Error> {
-        let mut hasher = Sha256::new();
-        let bytes = borsh::to_vec(&self)?;
-        hasher.update(bytes);
-        Ok(RevId::new(hasher.finalize().into()))
-    }
-
-    /// TODO
-    pub fn to_vec(&self) -> Result<Vec<u8>, crate::storage::Error> {
-        Ok(borsh::to_vec(&self)?)
-    }
-
-    /// TODO
-    pub fn from_slice(slice: &[u8]) -> Result<Self, crate::storage::Error> {
-        Ok(borsh::from_slice(slice)?)
-    }
-
-    /// The transaction fingerprint is a hash of the properties that are not allowed to be updated
-    /// in a transaction.
-    pub fn calculate_id(&self) -> Result<TxId, Error> {
-        let mut hasher = Sha256::new();
-        hasher.update(&borsh::to_vec(&self.spends)?);
-        hasher.update(&borsh::to_vec(&self.creates)?);
-        hasher.update(&self.typ.to_string());
-        hasher.update(&self.reference);
-        hasher.update(&self.created_at.timestamp_millis().to_string());
-        Ok(TxId::new(hasher.finalize().into()))
-    }
-
-    /// Validates the transaction input and output (debit and credit)
-    ///
-    /// The total sum of debits and credits should always be zero in transactions, unless they are
-    /// deposits or withdrawals.
-    ///
-    /// Negative amounts can be used in transactions, but the total sum of debits and credits should
-    /// always be zero, and the debit amount should be positive numbers
-    pub fn validate(&self) -> Result<(), Error> {
-        let mut debit = HashMap::<Asset, AmountCents>::new();
-        let mut credit = HashMap::<Asset, AmountCents>::new();
-
-        for input in self.spends.iter() {
-            if let Some(value) = debit.get_mut(input.amount.asset()) {
-                *value = input
-                    .amount
-                    .cents()
-                    .checked_add(*value)
-                    .ok_or(Error::Overflow)?;
-            } else {
-                debit.insert(input.amount.asset().clone(), input.amount.cents());
-            }
-        }
-
-        for (asset, amount) in debit.iter() {
-            if *amount <= 0 {
-                return Err(Error::InvalidAmount(
-                    asset.new_amount(*amount),
-                    asset.new_amount(*amount),
-                ));
-            }
-        }
-
-        if !self.typ.is_transaction() {
-            // We don't care input/output balance in external operations
-            // (withdrawals/deposits), because these operations are inbalanced
-            return Ok(());
-        }
-
-        for output in self.creates.iter() {
-            if let Some(value) = credit.get_mut(output.amount.asset()) {
-                *value = output
-                    .amount
-                    .cents()
-                    .checked_add(*value)
-                    .ok_or(Error::Overflow)?;
-            } else {
-                credit.insert(output.amount.asset().clone(), output.amount.cents());
-            }
-        }
-
-        for (asset, credit_amount) in credit.into_iter() {
-            if let Some(debit_amount) = debit.remove(&asset) {
-                if debit_amount != credit_amount {
-                    return Err(Error::InvalidAmount(
-                        asset.new_amount(debit_amount),
-                        asset.new_amount(credit_amount),
-                    ));
-                }
-            } else {
-                return Err(Error::MissingSpendingAsset(asset));
-            }
-        }
-
-        if let Some((asset, _)) = debit.into_iter().next() {
-            return Err(Error::MissingPaymentAsset(asset));
-        }
-
-        Ok(())
-    }
-}
-
-/// Transactions
-///
-/// A transaction is a set of payments being spent, to create a new set of payments. Payments can be
-/// spent only once. This simple model is inspired by Bitcoin's Unspent Transaction output model. In
-/// every transaction, the sum of the spends must equal the sum of the creates. Any difference will
-/// result in an error.
-///
-/// Every payment has a target account and the amount and asset.
-///
-/// Transactions are immutable, but since this is an append-only database, a newer version of the
-/// transaction can replace a previous version, as long as the transaction is not finalized.
-/// Previous transaction versions are kept forever and never pruned. The spend and create fields are
-/// not updatable, and the state of the transaction has a transition rule that will be enforced in
-/// each update. Furthermore, all new revisions must have a description of their update, inspired by
-/// a git commit message.
-///
-/// A Finalized transaction will either be settled (i.e. spendable) or reverted, in which case it is
-/// void but it is kept for historical reasons.
-///
-/// Although there is no concept of balances or accounts at this layer, the balance associated with
-/// an account is a sum of all received payments that were not spent.
-///
-/// The transaction ID, and the revision ID, are the cryptographic hash of the transactions
-#[derive(Debug, Clone, Serialize)]
-pub struct Transaction {
-    #[serde(rename = "_id")]
-    /// The TxId is the TxId of the first revision of the transaction.
-    pub id: TxId,
-
-    #[serde(rename = "_rev")]
-    /// Current Revision ID.
-    pub revision_id: RevId,
-
-    #[serde(rename = "_latest_rev")]
-    /// Latest revision of this transaction
-    pub lastest_revision: RevId,
-
-    /// The transaction inner details
-    #[serde(flatten)]
-    revision: Revision,
-}
-
-impl Transaction {
-    /// Creates a new external deposit transaction
-    ///
-    /// All transactions must be balanced, same amounts that are spent should be
-    /// created. There are two exceptions, external deposits and withdrawals.
-    /// The idea is to mimic external operations, where new assets enter the system.
-    pub fn new_external_deposit(
-        reference: String,
-        status: Status,
-        pay_to: Vec<(AccountId, Amount)>,
-    ) -> Result<Transaction, Error> {
-        Self::from_revision(
-            Revision {
-                changelog: "".to_owned(),
-                previous: None,
-                spends: vec![],
-                creates: pay_to
-                    .into_iter()
-                    .map(|(to, amount)| PaymentTo { to, amount })
-                    .collect(),
-                reference,
-                typ: Type::Deposit,
-                tags: Vec::new(),
-                status,
-                created_at: Utc::now(),
-                updated_at: Utc::now(),
-            },
-            None,
-        )
-    }
-
-    /// Creates a new external withdrawal transaction
-    ///
-    /// Burns assets to reflect external withdrawals
-    pub fn new_external_withdrawal(
-        reference: String,
-        status: Status,
-        spend: Vec<PaymentFrom>,
-    ) -> Result<Transaction, Error> {
-        Self::from_revision(
-            Revision {
-                changelog: "".to_owned(),
-                previous: None,
-                spends: spend,
-                creates: vec![],
-                reference,
-                typ: Type::Withdrawal,
-                tags: Vec::new(),
-                status,
-                created_at: Utc::now(),
-                updated_at: Utc::now(),
-            },
-            None,
-        )
-    }
-
-    /// Creates a new transaction
-    pub async fn new(
-        reference: String,
-        status: Status,
-        typ: Type,
-        spends: Vec<PaymentFrom>,
-        pay_to: Vec<(AccountId, Amount)>,
-    ) -> Result<Transaction, Error> {
-        // for (i, input) in spends.iter().enumerate() {
-        //     if !input.is_spendable_or_was_by(&id) {
-        //         return Err(Error::InvalidPaymentStatus(i, input.status.clone()));
-        //    }
-        // }
-        let create = pay_to
-            .into_iter()
-            .map(|(to, amount)| PaymentTo { to, amount })
-            .collect();
-
-        Self::from_revision(
-            Revision {
-                changelog: "".to_owned(),
-                previous: None,
-                spends,
-                creates: create,
-                reference,
-                typ,
-                tags: Vec::new(),
-                status,
-                created_at: Utc::now(),
-                updated_at: Utc::now(),
-            },
-            None,
-        )
-    }
-
-    /// Creates a new transaction object from a given revision
-    pub fn from_revision(
-        revision: Revision,
-        lastest_revision: Option<RevId>,
-    ) -> Result<Self, Error> {
-        let revision_id = revision.calculate_rev_id()?;
-        let lastest_revision = lastest_revision.unwrap_or_else(|| revision_id.clone());
-
-        Ok(Transaction {
-            id: revision.calculate_id()?,
-            revision_id,
-            lastest_revision,
-            revision,
-        })
-    }
-
-    /// Gets the inner transaction
-    pub fn revision(&self) -> &Revision {
-        &self.revision
-    }
-
-    /// Returns the previous revision of this transaction, if any
-    pub fn previous(&self) -> Option<RevId> {
-        self.revision.previous.clone()
-    }
-
-    /// Returns a unique list of accounts involved in this transaction.
-    ///
-    /// Accounts are sorted and unique, and they include the accounts that spent and that receives
-    pub fn accounts(&self) -> Vec<AccountId> {
-        let mut accounts = self
-            .revision
-            .creates
-            .iter()
-            .map(|x| x.to.clone())
-            .collect::<Vec<_>>();
-
-        accounts.extend(
-            self.revision
-                .spends
-                .iter()
-                .map(|x| x.from.clone())
-                .collect::<Vec<_>>(),
-        );
-
-        accounts.sort();
-        accounts.dedup();
-        accounts
-    }
-
-    /// Prepares a transaction ammend to update its status.
-    ///
-    /// If the status transaction is not allowed, it will return an error.
-    ///
-    /// The returned transaction is the newest version which is already persisted. The previous
-    /// version is not longer in memory
-    #[inline]
-    pub async fn change_status<S>(
-        self,
-        config: &Config<S>,
-        new_status: Status,
-        reason: String,
-    ) -> Result<Self, Error>
-    where
-        S: Storage + Sync + Send,
-    {
-        config
-            .status
-            .is_valid_transition(&self.revision.status, &new_status)?;
-        let mut inner = self.revision;
-        inner.changelog = reason;
-        inner.updated_at = Utc::now();
-        inner.previous = Some(self.revision_id);
-        inner.status = new_status;
-        let mut x: Transaction = Transaction::from_revision(inner, None)?;
-        x.persist(config).await?;
-        Ok(x)
-    }
-
-    /// Validates the transaction before storing
-    pub(crate) fn validate(&self) -> Result<(), Error> {
-        let calculated_revision_id = self.revision.calculate_rev_id()?;
-        let calculated_tx_id = self.revision.calculate_id()?;
-
-        if self.revision_id != calculated_revision_id || self.id != calculated_tx_id {
-            return Err(Error::InvalidTxId(self.id.clone(), calculated_tx_id));
-        }
-
-        self.revision.validate()
-    }
-
-    /// Returns the list of payments that were used to create this transaction
-    pub fn spends(&self) -> &[PaymentFrom] {
-        &self.revision.spends
-    }
-
-    /// Returns the list of payments that were created by this transaction
-    pub fn creates(&self) -> &[PaymentTo] {
-        &self.revision.creates
-    }
-
-    /// Returns the transaction ID
-    pub fn id(&self) -> &TxId {
-        &self.id
-    }
-
-    /// Returns the transaction status
-    pub fn status(&self) -> &Status {
-        &self.revision.status
-    }
-
-    /// Returns the transaction type
-    pub fn typ(&self) -> Type {
-        self.revision.typ
-    }
-
-    /// Returns the reference of this transaction
-    pub fn reference(&self) -> &str {
-        &self.revision.reference
-    }
-
-    /// Returns the time when this transaction was created
-    pub fn created_at(&self) -> DateTime<Utc> {
-        self.revision.created_at
-    }
-
-    /// Returns the time when this transaction was last updated
-    pub fn updated_at(&self) -> DateTime<Utc> {
-        self.revision.updated_at
-    }
-
-    /// 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, S>(&mut self, config: &'a Config<S>) -> Result<(), Error>
-    where
-        S: Storage + Sync + Send,
-    {
-        self.validate()?;
-
-        let mut batch = config.storage.begin().await?;
-
-        if let Some(previous_id) = &self.revision.previous {
-            // Make sure this update is updating the last revision and the status is not final
-            let current_transaction = batch.get_and_lock_transaction(&self.id).await?;
-
-            if config.status.is_final(&current_transaction.revision.status)
-                || self.revision.calculate_id()? != current_transaction.revision.calculate_id()?
-                || *previous_id != current_transaction.lastest_revision
-            {
-                return Err(Error::TransactionUpdatesNotAllowed);
-            }
-
-            // Updates all the spends to reflect the new status.
-            let (updated_created, updated_spent) =
-                if config.status.is_reverted(&self.revision.status) {
-                    // Release all the previously spent payments since the whole transaction is
-                    // being reverted due a failure or cancellation.
-                    batch
-                        .update_transaction_payments(
-                            &self.id,
-                            storage::Status::Failed,
-                            storage::Status::Spendable,
-                        )
-                        .await?
-                } else if config.status.is_spendable(&self.revision.status) {
-                    // Spend all the payments that were used to create this transaction
-                    batch
-                        .update_transaction_payments(
-                            &self.id,
-                            storage::Status::Spendable,
-                            storage::Status::Spent,
-                        )
-                        .await?
-                } else {
-                    // Lock both the spent transaction and the created transaction, since this
-                    // transaction is still not finalized
-                    batch
-                        .update_transaction_payments(
-                            &self.id,
-                            storage::Status::Locked,
-                            storage::Status::Locked,
-                        )
-                        .await?
-                };
-            if updated_created != self.revision.creates.len()
-                || updated_spent != self.revision.spends.len()
-            {
-                return Err(Error::NoUpdate);
-            }
-        } else {
-            let spends = self
-                .revision
-                .spends
-                .iter()
-                .map(|x| x.id.clone())
-                .collect::<Vec<_>>();
-            let (spent_payment_status, creates_payment_status) =
-                if config.status.is_spendable(&self.revision.status) {
-                    (storage::Status::Spent, storage::Status::Spendable)
-                } else {
-                    (storage::Status::Locked, storage::Status::Locked)
-                };
-            batch
-                .spend_payments(&self.id, spends, spent_payment_status)
-                .await?;
-            batch
-                .create_payments(&self.id, &self.revision.creates, creates_payment_status)
-                .await?;
-
-            for account in self.accounts() {
-                batch
-                    .relate_account_to_transaction(&self.id, &account, self.typ())
-                    .await?;
-            }
-        }
-
-        batch.store_transaction(self).await?;
-
-        //batch.tag_transaction(self, &self.inner.tags).await?;
-
-        batch.commit().await?;
-        Ok(())
-    }
-}

utxo/src/transaction/mod.rs

@@ -1,5 +1,318 @@
+use crate::{
+    config::Config,
+    payment::PaymentTo,
+    status::StatusType,
+    storage::{Batch, ReceivedPaymentStatus, Storage},
+    AccountId, Amount, PaymentFrom, RevId, Status, TxId,
+};
+use chrono::{DateTime, TimeZone, Utc};
+use serde::{Deserialize, Serialize};
+use std::ops::Deref;
+
+mod base_tx;
 mod error;
-pub mod inner;
+mod revision;
 mod typ;
 
-pub use self::{error::Error, inner::Transaction, typ::Type};
+pub use self::{base_tx::BaseTx, error::Error, revision::Revision, typ::Type};
+
+pub(crate) fn to_ts_microseconds<W: std::io::Write>(
+    dt: &DateTime<Utc>,
+    writer: &mut W,
+) -> std::io::Result<()> {
+    borsh::BorshSerialize::serialize(&dt.timestamp_millis(), writer)?;
+    Ok(())
+}
+
+pub(crate) fn from_ts_microseconds<R: borsh::io::Read>(
+    reader: &mut R,
+) -> ::core::result::Result<DateTime<Utc>, borsh::io::Error> {
+    match Utc.timestamp_millis_opt(borsh::BorshDeserialize::deserialize_reader(reader)?) {
+        chrono::LocalResult::Single(dt) => Ok(dt.with_timezone(&Utc)),
+        _ => Err(borsh::io::Error::new(
+            borsh::io::ErrorKind::InvalidData,
+            "invalid timestamp".to_owned(),
+        )),
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+/// A transaction with a revision
+///
+/// This is the public representation of a transaction, with the revision. Since transactions are
+/// immutable, the revision is the only way to update them.
+///
+/// A Revision is an ammenment to a transaction, but it can only ammend a few fields of the
+/// transaction, mainly their status and certain unrelated fields to the transactions, such as tags.
+///
+/// Revisions are only updatable until the transaction is finalized, by which point they are also
+/// immutable.
+///
+/// Having a revision also makes concurrency easier, since only the latest revision can may be
+/// upgraded, any other attempt to ammend a stale revision will be rejected.
+pub struct Transaction {
+    /// Transaction ID
+    #[serde(rename = "_id")]
+    pub id: TxId,
+
+    /// Revision ID
+    #[serde(rename = "_rev")]
+    pub revision_id: RevId,
+
+    /// The revision struct.
+    #[serde(flatten)]
+    pub revision: Revision,
+
+    #[serde(flatten)]
+    /// The transaction struct
+    pub transaction: BaseTx,
+}
+
+impl Deref for Transaction {
+    type Target = BaseTx;
+
+    fn deref(&self) -> &Self::Target {
+        &self.transaction
+    }
+}
+
+impl TryFrom<(BaseTx, Revision)> for Transaction {
+    type Error = Error;
+
+    fn try_from(value: (BaseTx, Revision)) -> Result<Self, Self::Error> {
+        Ok(Self {
+            id: value.0.id()?,
+            revision_id: value.1.rev_id()?,
+            revision: value.1,
+            transaction: value.0,
+        })
+    }
+}
+
+#[allow(dead_code)]
+impl Transaction {
+    /// Creates a new transaction
+    pub async fn new(
+        reference: String,
+        status: Status,
+        typ: Type,
+        spends: Vec<PaymentFrom>,
+        creates: Vec<(AccountId, Amount)>,
+    ) -> Result<Self, Error> {
+        let creates = creates
+            .into_iter()
+            .map(|(to, amount)| PaymentTo { to, amount })
+            .collect();
+
+        let (transaction, revision) = BaseTx::new(spends, creates, reference, typ, status)?;
+
+        Ok(Self {
+            id: transaction.id()?,
+            revision_id: revision.rev_id()?,
+            revision,
+            transaction,
+        })
+    }
+
+    /// Creates a new external deposit transaction
+    ///
+    /// All transactions must be balanced, same amounts that are spent should be
+    /// created. There are two exceptions, external deposits and withdrawals.
+    /// The idea is to mimic external operations, where new assets enter the system.
+    pub fn new_external_deposit(
+        reference: String,
+        status: Status,
+        creates: Vec<(AccountId, Amount)>,
+    ) -> Result<Self, Error> {
+        let creates = creates
+            .into_iter()
+            .map(|(to, amount)| PaymentTo { to, amount })
+            .collect();
+        let (transaction, revision) =
+            BaseTx::new(Vec::new(), creates, reference, Type::Deposit, status)?;
+
+        Ok(Self {
+            id: transaction.id()?,
+            revision_id: revision.rev_id()?,
+            revision,
+            transaction,
+        })
+    }
+
+    /// Creates a new external withdrawal transaction
+    ///
+    /// Burns assets to reflect external withdrawals
+    pub fn new_external_withdrawal(
+        reference: String,
+        status: Status,
+        spends: Vec<PaymentFrom>,
+    ) -> Result<Self, Error> {
+        let (transaction, revision) =
+            BaseTx::new(spends, Vec::new(), reference, Type::Withdrawal, status)?;
+
+        Ok(Self {
+            id: transaction.id()?,
+            revision_id: revision.rev_id()?,
+            transaction,
+            revision,
+        })
+    }
+
+    /// Returns the transaction ID
+    pub fn id(&self) -> &TxId {
+        &self.id
+    }
+
+    /// Prepares a new revision to change the transaction status
+    ///
+    /// If the status transaction is not allowed, it will return an error.
+    ///
+    /// The new transaction with revision is returned, which is already persisted. The previous
+    /// struct is consumed and the latest revision is preserved for historical purposes but it is no
+    /// longer the latest revision
+    #[inline]
+    pub async fn change_status<S>(
+        self,
+        config: &Config<S>,
+        new_status: Status,
+        reason: String,
+    ) -> Result<Self, Error>
+    where
+        S: Storage + Sync + Send,
+    {
+        config
+            .status
+            .is_valid_transition(&self.revision.status, &new_status)?;
+        let new_revision = Revision {
+            transaction_id: self.revision.transaction_id,
+            changelog: reason,
+            previous: Some(self.revision_id),
+            tags: self.revision.tags,
+            status: new_status,
+            created_at: Utc::now(),
+        };
+        let mut new_transaction = Transaction {
+            id: self.id,
+            revision_id: new_revision.rev_id()?,
+            transaction: self.transaction,
+            revision: new_revision,
+        };
+        new_transaction.persist(config).await?;
+        Ok(new_transaction)
+    }
+
+    fn validate(&self) -> Result<(), Error> {
+        let rev_id = self.revision.rev_id()?;
+        let tx_id = self.transaction.id()?;
+        if self.revision_id != rev_id {
+            return Err(Error::InvalidRevId(self.revision_id.clone(), rev_id));
+        }
+        if tx_id != self.revision.transaction_id || tx_id != self.id {
+            return Err(Error::InvalidTxId(
+                tx_id,
+                self.revision.transaction_id.clone(),
+            ));
+        }
+        self.transaction.validate()?;
+        Ok(())
+    }
+
+    #[inline]
+    async fn store_transaction<'a, S>(&mut self, batch: &mut S::Batch<'a>) -> Result<(), Error>
+    where
+        S: Storage + Sync + Send,
+    {
+        self.validate()?;
+        let spends = self.spends.iter().map(|x| x.id.clone()).collect::<Vec<_>>();
+        batch
+            .spend_payments(
+                &self.revision.transaction_id,
+                spends,
+                ReceivedPaymentStatus::Locked,
+            )
+            .await?;
+        batch
+            .create_payments(
+                &self.revision.transaction_id,
+                &self.creates,
+                ReceivedPaymentStatus::Locked,
+            )
+            .await?;
+
+        for account in self.accounts() {
+            batch
+                .relate_account_to_transaction(&self.revision.transaction_id, &account, self.typ)
+                .await?;
+        }
+        batch
+            .store_base_transaction(&self.revision.transaction_id, &self.transaction)
+            .await?;
+        Ok(())
+    }
+
+    /// 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, S>(&mut self, config: &'a Config<S>) -> Result<(), Error>
+    where
+        S: Storage + Sync + Send,
+    {
+        self.validate()?;
+        let mut batch = config.storage.begin().await?;
+        if self.revision.previous.is_none() {
+            self.store_transaction::<S>(&mut batch).await?;
+        }
+
+        let (created_updated, spent_updated) = match config.status.typ(&self.revision.status) {
+            StatusType::Reverted => batch
+                .update_transaction_payments(
+                    &self.id,
+                    ReceivedPaymentStatus::Failed,
+                    ReceivedPaymentStatus::Spendable,
+                )
+                .await
+                .expect("foo0"),
+            StatusType::Spendable => batch
+                .update_transaction_payments(
+                    &self.id,
+                    ReceivedPaymentStatus::Spendable,
+                    ReceivedPaymentStatus::Spent,
+                )
+                .await
+                .expect("foo1"),
+            _ => (self.creates.len(), self.spends.len()),
+        };
+
+        if self.creates.len() != created_updated || self.spends.len() != spent_updated {
+            return Err(Error::NoUpdate);
+        }
+
+        if config.status.is_spendable(&self.revision.status) {
+            batch
+                .update_transaction_payments(
+                    &self.id,
+                    ReceivedPaymentStatus::Spendable,
+                    ReceivedPaymentStatus::Spent,
+                )
+                .await
+                .expect("foo2");
+        }
+
+        batch
+            .store_revision(&self.revision_id, &self.revision)
+            .await?;
+
+        batch
+            .update_transaction_revision(
+                &self.id,
+                &self.revision_id,
+                self.revision.previous.as_ref(),
+            )
+            .await
+            .expect("foo3");
+
+        batch.commit().await?;
+
+        Ok(())
+    }
+}

utxo/src/transaction/revision.rs

@@ -0,0 +1,71 @@
+use crate::{transaction::Error, RevId, Status, TxId};
+use chrono::{serde::ts_milliseconds, DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+
+#[derive(Debug, Clone, Deserialize, Serialize, borsh::BorshSerialize, borsh::BorshDeserialize)]
+/// A transaction revision
+pub struct Revision {
+    #[serde(rename = "_id")]
+    /// TransactionId
+    pub transaction_id: TxId,
+
+    /// Previous revision or None if this is the first revision
+    #[serde(rename = "_prev_rev")]
+    pub previous: Option<RevId>,
+
+    /// A human-readable changelog for this revision
+    pub changelog: String,
+
+    /// Vector of tags associated with a transaction
+    pub tags: Vec<String>,
+
+    /// Transaction status
+    pub status: Status,
+
+    #[serde(rename = "updated_at", with = "ts_milliseconds")]
+    #[borsh(
+        serialize_with = "super::to_ts_microseconds",
+        deserialize_with = "super::from_ts_microseconds"
+    )]
+    /// Timestamp when this revision has been created
+    pub created_at: DateTime<Utc>,
+}
+
+impl Revision {
+    /// Creates a new revision
+    pub fn new(
+        transaction_id: TxId,
+        previous: Option<RevId>,
+        changelog: String,
+        tags: Vec<String>,
+        status: Status,
+    ) -> Self {
+        Self {
+            transaction_id,
+            previous,
+            changelog,
+            tags,
+            status,
+            created_at: Utc::now(),
+        }
+    }
+
+    /// Calculates the ID of the inner revision
+    pub fn rev_id(&self) -> Result<RevId, Error> {
+        let mut hasher = Sha256::new();
+        let bytes = borsh::to_vec(self)?;
+        hasher.update(&bytes);
+        Ok(RevId::new(hasher.finalize().into()))
+    }
+
+    /// Returns the transaction ID
+    pub fn transaction_id(&self) -> &TxId {
+        &self.transaction_id
+    }
+
+    /// Returns the revision ID
+    pub fn previous_revision_id(&self) -> Option<&RevId> {
+        self.previous.as_ref()
+    }
+}