More changes

src/main.rs

@@ -12,6 +12,29 @@ pub struct Movement {
 }
 
 #[derive(Deserialize)]
+pub struct Deposit {
+    pub account: AccountId,
+    pub amount: String,
+    pub asset: String,
+    pub memo: String,
+}
+
+impl Deposit {
+    pub async fn to_ledger_transaction(
+        self,
+        ledger: &Ledger,
+    ) -> Result<ledger_utxo::Transaction, ledger_utxo::Error> {
+        /*
+        ledger
+            ._inner
+            .deposit(self.account, self.amount, self.asset, self.memo)
+            .await
+            */
+        todo!()
+    }
+}
+
+#[derive(Deserialize)]
 pub struct Transaction {
     pub debit: Vec<Movement>,
     pub credit: Vec<Movement>,
@@ -19,6 +42,19 @@ pub struct Transaction {
     pub status: Status,
 }
 
+impl Transaction {
+    pub async fn to_ledger_transaction(
+        self,
+        ledger: &Ledger,
+    ) -> Result<ledger_utxo::Transaction, ledger_utxo::Error> {
+        todo!()
+        /*ledger
+        ._inner
+        .new_transaction(self.memo, self.status, from, to)
+        .await*/
+    }
+}
+
 #[derive(Serialize, Deserialize)]
 struct Item {
     id: i32,
@@ -26,11 +62,13 @@ struct Item {
 }
 
 #[get("/tx/{id}")]
-async fn get_item(info: web::Path<TransactionId>, ledger: web::Data<Ledger>) -> impl Responder {
+async fn get_transaction(
+    info: web::Path<TransactionId>,
+    ledger: web::Data<Ledger>,
+) -> impl Responder {
     // Retrieve an item by ID from a database or another data source.
     // For this example, we'll return a hardcoded item.
 
-    return HttpResponse::Ok().json(json!(info.0));
     let tx = ledger._inner.get_transaction(&info.0).await;
     println!("{:?}", tx);
 
@@ -41,11 +79,31 @@ async fn get_item(info: web::Path<TransactionId>, ledger: web::Data<Ledger>) ->
     }
 }
 
-#[post("/items")]
-async fn create_item(item: web::Json<Transaction>, _ledger: web::Data<Ledger>) -> impl Responder {
+#[post("/deposit")]
+async fn deposit(item: web::Json<Deposit>, ledger: web::Data<Ledger>) -> impl Responder {
     // Insert the item into a database or another data source.
     // For this example, we'll just echo the received item.
-    HttpResponse::Created().json(json!({"test": "true"}))
+    if let Ok(tx) = item.into_inner().to_ledger_transaction(&ledger).await {
+        // Insert the item into a database or another data source.
+        // For this example, we'll just echo the received item.
+        HttpResponse::Created().json(tx)
+    } else {
+        HttpResponse::Created().json(json!({"test": "true"}))
+    }
+}
+
+#[post("/tx")]
+async fn create_transaction(
+    item: web::Json<Transaction>,
+    ledger: web::Data<Ledger>,
+) -> impl Responder {
+    if let Ok(tx) = item.into_inner().to_ledger_transaction(&ledger).await {
+        // Insert the item into a database or another data source.
+        // For this example, we'll just echo the received item.
+        HttpResponse::Created().json(tx)
+    } else {
+        HttpResponse::Created().json(json!({"test": "true"}))
+    }
 }
 
 pub struct Ledger {
@@ -76,11 +134,12 @@ async fn main() -> std::io::Result<()> {
 
         HttpServer::new(move || {
             let storage = ledger_utxo::Sqlite::new(pool.clone(), asset_manager.clone());
-            let ledger = ledger_utxo::Ledger::new(storage);
+            let ledger = ledger_utxo::Ledger::new(storage, asset_manager.clone());
             App::new()
                 .data(Ledger { _inner: ledger })
-                .service(get_item)
-                .service(create_item)
+                .service(get_transaction)
+                .service(deposit)
+                .service(create_transaction)
         })
         .bind("127.0.0.1:8080")?
         .run()

utxo/src/asset_manager.rs

@@ -4,6 +4,7 @@ use std::{collections::HashMap, sync::Arc};
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct AssetManager {
     assets: Arc<HashMap<AssetId, AssetDefinition>>,
+    asset_names: Arc<HashMap<Arc<str>, AssetDefinition>>,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize)]
@@ -18,8 +19,14 @@ impl AssetManager {
         Self {
             assets: Arc::new(
                 assets
+                    .iter()
+                    .map(|asset| (asset.asset.id, asset.clone()))
+                    .collect(),
+            ),
+            asset_names: Arc::new(
+                assets
                     .into_iter()
-                    .map(|asset| (asset.asset.id, asset))
+                    .map(|asset| (asset.name.clone(), asset))
                     .collect(),
             ),
         }
@@ -29,17 +36,21 @@ impl AssetManager {
         self.assets
             .get(&id)
             .map(|asset| asset.asset)
-            .ok_or(Error::AssetNotFound(id))
+            .ok_or(Error::AssetIdNotFound(id))
     }
 
-    pub fn asset_name(&self, asset: &Asset) -> Result<Arc<str>, Error> {
-        self.assets
-            .get(&asset.id)
-            .map(|asset| asset.name.clone())
-            .ok_or(Error::AssetNotFound(asset.id))
+    pub fn amount_by_name(&self, name: &str, amount: &str) -> Result<Amount, Error> {
+        self.asset_names
+            .get(name)
+            .map(|asset| {
+                //let amount = AmountCents::from_str(amount)?;
+                //Amount::new(asset.asset, amount)
+                todo!()
+            })
+            .ok_or(Error::AssetNotFound(name.to_owned()))
     }
 
-    pub fn amount(&self, id: AssetId, cents: AmountCents) -> Result<Amount, Error> {
+    pub fn amount_by_and_cents(&self, id: AssetId, cents: AmountCents) -> Result<Amount, Error> {
         self.asset(id).map(|asset| Amount::new(asset, cents))
     }
 }

utxo/src/error.rs

@@ -9,7 +9,10 @@ pub enum Error {
     Storage(#[from] storage::Error),
 
     #[error("Asset {0} is not defined")]
-    AssetNotFound(AssetId),
+    AssetIdNotFound(AssetId),
+
+    #[error("Asset {0} is not defined")]
+    AssetNotFound(String),
 
     #[error("Not enough funds (asset {1}) for account {0}")]
     InsufficientBalance(AccountId, AssetId),

utxo/src/ledger.rs

@@ -1,6 +1,7 @@
 use crate::{
     storage::{Batch, Storage},
-    AccountId, Amount, Error, Payment, Status, Transaction, TransactionId,
+    transaction::Type,
+    AccountId, Amount, AssetManager, Error, Payment, Status, Transaction, TransactionId,
 };
 use std::{cmp::Ordering, collections::HashMap};
 
@@ -11,6 +12,7 @@ where
     S: Storage<'a, B> + Sync + Send,
 {
     storage: S,
+    asset_manager: AssetManager,
     _phantom: std::marker::PhantomData<&'a B>,
 }
 
@@ -19,13 +21,18 @@ where
     B: Batch<'a>,
     S: Storage<'a, B> + Sync + Send,
 {
-    pub fn new(storage: S) -> Self {
+    pub fn new(storage: S, asset_manager: AssetManager) -> Self {
         Self {
             storage,
+            asset_manager,
             _phantom: std::marker::PhantomData,
         }
     }
 
+    pub fn parse_amount(&self, amount: &str, asset: &str) -> Result<Amount, Error> {
+        Ok(self.asset_manager.amount_by_name(amount, asset)?)
+    }
+
     /// Selects the unspent payments to be used as inputs of the new transaction.
     ///
     /// This function also returns a list of transactions that will be used as
@@ -49,7 +56,7 @@ where
             }
         }
 
-        let mut change = vec![];
+        let mut change_transactions = vec![];
         let mut payments: Vec<Payment> = vec![];
 
         for ((account, asset), mut to_spend_cents) in to_spend.into_iter() {
@@ -80,7 +87,7 @@ where
                             .pop()
                             .ok_or(Error::InsufficientBalance(account.clone(), asset.id))?;
                         let split_input = Transaction::new(
-                            "Exchange".to_owned(),
+                            "Exchange transaction".to_owned(),
                             // Set the change transaction as settled. This is an
                             // internal transaction to split an existing payment
                             // into two. Since this is an internal transaction it
@@ -91,6 +98,7 @@ where
                             // otherwise it would be locked until the main
                             // transaction settles.
                             Status::Settled,
+                            Type::Internal,
                             vec![input],
                             vec![
                                 (account.clone(), asset.new_amount(cents - to_spend_cents)),
@@ -102,7 +110,7 @@ where
                         payments.push(split_input.created()[0].clone());
                         // Return the split payment transaction to be executed
                         // later as a pre-requisite for the new transaction
-                        change.push(split_input);
+                        change_transactions.push(split_input);
 
                         // Go to the next payment input or exit the loop
                         break;
@@ -121,7 +129,7 @@ where
             }
         }
 
-        Ok((change, payments))
+        Ok((change_transactions, payments))
     }
 
     /// Creates a new transaction and returns it.
@@ -157,7 +165,8 @@ where
             change_tx.persist(&self.storage).await?;
         }
 
-        let mut transaction = Transaction::new(reference, status, payments, to).await?;
+        let mut transaction =
+            Transaction::new(reference, status, Type::Transaction, payments, to).await?;
         transaction.persist(&self.storage).await?;
         Ok(transaction)
     }
@@ -204,6 +213,7 @@ where
         Ok(transaction)
     }
 
+    /// Returns the transaction object by a given transaction id
     pub async fn get_transaction(
         &'a self,
         transaction_id: &TransactionId,
@@ -215,6 +225,27 @@ where
             .try_into()?)
     }
 
+    /// Returns all transactions from a given account. It can be optionally be
+    /// sorted by transaction type. The transactions are sorted from newest to
+    /// oldest.
+    pub async fn get_transactions(
+        &'a self,
+        account_id: &AccountId,
+        typ: Option<Type>,
+    ) -> Result<Vec<Transaction>, Error> {
+        let r = self
+            .storage
+            .get_transactions(account_id, typ)
+            .await?
+            .into_iter()
+            .map(|x| x.try_into())
+            .collect::<Result<Vec<Transaction>, _>>()?;
+
+        Ok(r)
+    }
+
+    /// Attemps to change the status of a given transaction id. On success the
+    /// new transaction object is returned, otherwise an error is returned.
     pub async fn change_status(
         &'a self,
         transaction_id: &TransactionId,

utxo/src/sqlite/batch.rs

@@ -123,14 +123,15 @@ impl<'a> storage::Batch<'a> for Batch<'a> {
     async fn store_transaction(&mut self, transaction: &Transaction) -> Result<(), Error> {
         sqlx::query(
             r#"
-                INSERT INTO "transactions"("transaction_id", "status", "reference", "created_at", "updated_at")
-                VALUES(?, ?, ?, ?, ?)
+                INSERT INTO "transactions"("transaction_id", "status", "type", "reference", "created_at", "updated_at")
+                VALUES(?, ?, ?, ?, ?, ?)
                 ON CONFLICT("transaction_id")
                     DO UPDATE SET "status" = excluded."status", "reference" = excluded."reference", "updated_at" = excluded."updated_at"
             "#,
         )
         .bind(transaction.id().to_string())
         .bind::<u32>(transaction.status().into())
+        .bind::<u32>(transaction.typ().into())
         .bind(transaction.reference())
         .bind(transaction.created_at().timestamp())
         .bind(transaction.updated_at().timestamp())
@@ -160,19 +161,22 @@ impl<'a> storage::Batch<'a> for Batch<'a> {
 
     async fn relate_account_to_transaction(
         &mut self,
-        transaction_id: &TransactionId,
+        transaction: &Transaction,
         account: &AccountId,
     ) -> Result<(), Error> {
         sqlx::query(
             r#"
-            INSERT INTO "transaction_accounts"("transaction_id", "account_id")
-            VALUES(?, ?)
+            INSERT INTO "transaction_accounts"("transaction_id", "account_id", "type", "created_at", "updated_at")
+            VALUES(?, ?, ?, ?, ?)
             ON CONFLICT("transaction_id", "account_id")
                 DO NOTHING
             "#,
         )
-        .bind(transaction_id.to_string())
+        .bind(transaction.id().to_string())
         .bind(account.to_string())
+        .bind::<u32>(transaction.typ().into())
+        .bind(transaction.created_at().timestamp())
+        .bind(transaction.updated_at().timestamp())
         .execute(&mut *self.inner)
         .await
         .map_err(|e| Error::Storage(e.to_string()))?;

utxo/src/sqlite/mod.rs

@@ -2,7 +2,7 @@ use crate::{
     amount::AmountCents,
     asset::AssetId,
     storage::{Error, Storage},
-    transaction::from_db,
+    transaction::{from_db, Type},
     AccountId, Amount, Asset, AssetManager, Payment, PaymentId, Status, TransactionId,
 };
 use chrono::NaiveDateTime;
@@ -48,6 +48,7 @@ impl<'a> Sqlite<'a> {
             CREATE TABLE IF NOT EXISTS "transactions" (
                 "transaction_id" VARCHAR(66) NOT NULL,
                 "status" INTEGER NOT NULL,
+                "type" INTEGER NOT NULL,
                 "reference" TEXT NOT NULL,
                 "created_at" DATETIME DEFAULT CURRENT_TIMESTAMP,
                 "updated_at" DATETIME DEFAULT CURRENT_TIMESTAMP,
@@ -56,8 +57,12 @@ impl<'a> Sqlite<'a> {
             CREATE TABLE IF NOT EXISTS "transaction_accounts" (
                 "transaction_id" VARCHAR(66) NOT NULL,
                 "account_id" VARCHAR(71) NOT NULL,
+                "type" INTEGER NOT NULL,
+                "created_at" DATETIME DEFAULT CURRENT_TIMESTAMP,
+                "updated_at" DATETIME DEFAULT CURRENT_TIMESTAMP,
                 PRIMARY KEY("account_id", "transaction_id")
             );
+            CREATE INDEX "type" ON "transaction_accounts" ("account_id", "type", "created_at");
             CREATE TABLE IF NOT EXISTS "transaction_input_payments" (
                 "transaction_id" VARCHAR(66) NOT NULL,
                 "payment_transaction_id" VARCHAR(66) NOT NULL,
@@ -301,6 +306,7 @@ impl<'a> Storage<'a, Batch<'a>> for Sqlite<'a> {
             r#"
             SELECT
                 "t"."status",
+                "t"."type",
                 "t"."reference",
                 "t"."created_at",
                 "t"."updated_at"
@@ -387,17 +393,23 @@ impl<'a> Storage<'a, Batch<'a>> for Sqlite<'a> {
             .map_err(|_| Error::Storage("Invalid status".to_string()))?
             .try_into()
             .map_err(|_| Error::Storage("Invalid status".to_string()))?;
+        let typ = transaction_row
+            .try_get::<u32, usize>(1)
+            .map_err(|_| Error::Storage("Invalid type".to_string()))?
+            .try_into()
+            .map_err(|_| Error::Storage("Invalid type".to_string()))?;
+
         let reference = transaction_row
-            .try_get::<String, usize>(1)
+            .try_get::<String, usize>(2)
             .map_err(|_| Error::Storage("Invalid reference".to_string()))?;
 
         let created_at = transaction_row
-            .try_get::<NaiveDateTime, usize>(2)
+            .try_get::<NaiveDateTime, usize>(3)
             .map_err(|e| Error::InvalidDate(e.to_string()))?
             .and_utc();
 
         let updated_at = transaction_row
-            .try_get::<NaiveDateTime, usize>(3)
+            .try_get::<NaiveDateTime, usize>(4)
             .map_err(|e| Error::InvalidDate(e.to_string()))?
             .and_utc();
 
@@ -405,10 +417,58 @@ impl<'a> Storage<'a, Batch<'a>> for Sqlite<'a> {
             id: transaction_id.clone(),
             spend,
             create,
+            typ,
             status,
             reference,
             created_at,
             updated_at,
         })
     }
+
+    async fn get_transactions(
+        &self,
+        account: &AccountId,
+        typ: Option<Type>,
+    ) -> Result<Vec<from_db::Transaction>, Error> {
+        let mut conn = self
+            .db
+            .acquire()
+            .await
+            .map_err(|e| Error::Storage(e.to_string()))?;
+
+        let sql = sqlx::query(if typ.is_some() {
+            r#"SELECT "transaction_id" FROM "transaction_accounts" WHERE "account_id" = ? AND "type" = ?" ORDER BY "created_at" DESC"#
+        } else {
+            r#"SELECT "transaction_id" FROM "transaction_accounts" WHERE "account_id" = ? ORDER BY "created_at" DESC"#
+        }).bind(account.to_string());
+
+        let ids = if let Some(typ) = typ {
+            sql.bind::<u32>(typ.into())
+        } else {
+            sql
+        }
+        .fetch_all(&mut *conn)
+        .await
+        .map_err(|e| Error::Storage(e.to_string()))?
+        .iter()
+        .map(|row| {
+            let id: Result<TransactionId, _> = row
+                .try_get::<String, usize>(0)
+                .map_err(|_| Error::Storage("Invalid transaction_id".to_string()))?
+                .as_str()
+                .try_into();
+
+            id.map_err(|_| Error::Storage("Invalid transaction_id length".to_string()))
+        })
+        .collect::<Result<Vec<_>, Error>>()?;
+
+        drop(conn);
+
+        let mut transactions = vec![];
+        for id in ids.into_iter() {
+            transactions.push(self.get_transaction(&id).await?);
+        }
+
+        Ok(transactions)
+    }
 }

utxo/src/status.rs

@@ -60,13 +60,7 @@ impl TryFrom<u32> for Status {
 
 impl From<Status> for u32 {
     fn from(value: Status) -> Self {
-        match value {
-            Status::Pending => 0,
-            Status::Processing => 10,
-            Status::Cancelled => 20,
-            Status::Settled => 30,
-            Status::Failed => 40,
-        }
+        (&value).into()
     }
 }
 

utxo/src/storage.rs

@@ -1,6 +1,8 @@
 use crate::{
-    amount::AmountCents, asset::AssetId, transaction::from_db, AccountId, Amount, Payment,
-    PaymentId, Status, Transaction, TransactionId,
+    amount::AmountCents,
+    asset::AssetId,
+    transaction::{from_db, Type},
+    AccountId, Amount, Payment, PaymentId, Status, Transaction, TransactionId,
 };
 
 #[derive(thiserror::Error, Debug)]
@@ -49,7 +51,7 @@ pub trait Batch<'a> {
 
     async fn relate_account_to_transaction(
         &mut self,
-        transaction_id: &TransactionId,
+        transaction: &Transaction,
         account: &AccountId,
     ) -> Result<(), Error>;
 }
@@ -88,8 +90,8 @@ where
 
     /// Returns a list of unspent payments for a given account and asset.
     ///
-    /// The payments are returned sorted by ascending amount, this bit is
-    /// important to make sure that all negative payment is always taken into
+    /// The payments should be returned sorted by ascending amount, this bit is
+    /// important to make sure that all negative payments are always taken into
     /// account. It will also improve the database by using many small payments
     /// instead of a few large ones, which will make the database faster leaving
     /// fewer unspent payments when checking for balances.
@@ -105,4 +107,13 @@ where
         &self,
         transaction_id: &TransactionId,
     ) -> Result<from_db::Transaction, Error>;
+
+    /// Returns a list of a transactions for a given account (and optionally
+    /// filter by types). The list of transactions is expected to be sorted by
+    /// date desc (newest transactions first)
+    async fn get_transactions(
+        &self,
+        account: &AccountId,
+        typ: Option<Type>,
+    ) -> Result<Vec<from_db::Transaction>, Error>;
 }

utxo/src/tests/deposit.rs

@@ -8,7 +8,7 @@ async fn pending_deposit_and_failure() {
     let id = ledger
         .deposit(
             &source,
-            assets.amount(2, 3000).expect("amount"),
+            assets.amount_by_and_cents(2, 3000).expect("amount"),
             Status::Processing,
             "Test".to_owned(),
         )
@@ -42,11 +42,21 @@ async fn deposit_and_transfer() {
     let fee = "fee".parse::<AccountId>().expect("account");
     let (assets, ledger) = get_instance().await;
 
-    deposit(&ledger, &source, assets.amount(2, 1000).expect("amount")).await;
-    deposit(&ledger, &source, assets.amount(2, 2000).expect("amount")).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(2, 3000).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 3000).expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
 
@@ -54,25 +64,34 @@ async fn deposit_and_transfer() {
         .new_transaction(
             "Exchange one".to_owned(),
             Status::Settled,
-            vec![(source.clone(), assets.amount(2, 1300).expect("amount"))],
+            vec![(
+                source.clone(),
+                assets.amount_by_and_cents(2, 1300).expect("amount"),
+            )],
             vec![
-                (dest.clone(), assets.amount(2, 1250).expect("amount")),
-                (fee.clone(), assets.amount(2, 50).expect("amount")),
+                (
+                    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(2, 1700).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount(2, 1250).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 1250).expect("amount")],
         ledger.get_balance(&dest).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount(2, 50).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 50).expect("amount")],
         ledger.get_balance(&fee).await.expect("balance")
     );
 }
@@ -84,11 +103,21 @@ async fn balance_decreases_while_pending_spending_and_confirm() {
     let fee = "fee".parse::<AccountId>().expect("account");
     let (assets, ledger) = get_instance().await;
 
-    deposit(&ledger, &source, assets.amount(2, 1000).expect("amount")).await;
-    deposit(&ledger, &source, assets.amount(2, 2000).expect("amount")).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(2, 3000).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 3000).expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
 
@@ -96,10 +125,19 @@ async fn balance_decreases_while_pending_spending_and_confirm() {
         .new_transaction(
             "Exchange one".to_owned(),
             Status::Pending,
-            vec![(source.clone(), assets.amount(2, 1300).expect("amount"))],
+            vec![(
+                source.clone(),
+                assets.amount_by_and_cents(2, 1300).expect("amount"),
+            )],
             vec![
-                (dest.clone(), assets.amount(2, 1250).expect("amount")),
-                (fee.clone(), assets.amount(2, 50).expect("amount")),
+                (
+                    dest.clone(),
+                    assets.amount_by_and_cents(2, 1250).expect("amount"),
+                ),
+                (
+                    fee.clone(),
+                    assets.amount_by_and_cents(2, 50).expect("amount"),
+                ),
             ],
         )
         .await
@@ -108,7 +146,7 @@ async fn balance_decreases_while_pending_spending_and_confirm() {
         .clone();
 
     assert_eq!(
-        vec![assets.amount(2, 1700).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
     assert!(ledger.get_balance(&dest).await.expect("balance").is_empty());
@@ -120,15 +158,15 @@ async fn balance_decreases_while_pending_spending_and_confirm() {
         .expect("valid tx");
 
     assert_eq!(
-        vec![assets.amount(2, 1700).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount(2, 1250).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 1250).expect("amount")],
         ledger.get_balance(&dest).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount(2, 50).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 50).expect("amount")],
         ledger.get_balance(&fee).await.expect("balance")
     );
 }
@@ -140,11 +178,21 @@ async fn balance_decreases_while_pending_spending_and_cancel() {
     let fee = "fee".parse::<AccountId>().expect("account");
     let (assets, ledger) = get_instance().await;
 
-    deposit(&ledger, &source, assets.amount(2, 1000).expect("amount")).await;
-    deposit(&ledger, &source, assets.amount(2, 2000).expect("amount")).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(2, 3000).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 3000).expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
 
@@ -152,10 +200,19 @@ async fn balance_decreases_while_pending_spending_and_cancel() {
         .new_transaction(
             "Exchange one".to_owned(),
             Status::Pending,
-            vec![(source.clone(), assets.amount(2, 1300).expect("amount"))],
+            vec![(
+                source.clone(),
+                assets.amount_by_and_cents(2, 1300).expect("amount"),
+            )],
             vec![
-                (dest.clone(), assets.amount(2, 1250).expect("amount")),
-                (fee.clone(), assets.amount(2, 50).expect("amount")),
+                (
+                    dest.clone(),
+                    assets.amount_by_and_cents(2, 1250).expect("amount"),
+                ),
+                (
+                    fee.clone(),
+                    assets.amount_by_and_cents(2, 50).expect("amount"),
+                ),
             ],
         )
         .await
@@ -164,7 +221,7 @@ async fn balance_decreases_while_pending_spending_and_cancel() {
         .clone();
 
     assert_eq!(
-        vec![assets.amount(2, 1700).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
     assert!(ledger.get_balance(&dest).await.expect("balance").is_empty());
@@ -176,7 +233,7 @@ async fn balance_decreases_while_pending_spending_and_cancel() {
         .expect("valid tx");
 
     assert_eq!(
-        vec![assets.amount(2, 3000).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 3000).expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
     assert!(ledger.get_balance(&dest).await.expect("balance").is_empty());
@@ -190,11 +247,21 @@ async fn balance_decreases_while_pending_spending_and_failed() {
     let fee = "fee".parse::<AccountId>().expect("account");
     let (assets, ledger) = get_instance().await;
 
-    deposit(&ledger, &source, assets.amount(2, 1000).expect("amount")).await;
-    deposit(&ledger, &source, assets.amount(2, 2000).expect("amount")).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(2, 3000).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 3000).expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
 
@@ -202,10 +269,19 @@ async fn balance_decreases_while_pending_spending_and_failed() {
         .new_transaction(
             "Exchange one".to_owned(),
             Status::Pending,
-            vec![(source.clone(), assets.amount(2, 1300).expect("amount"))],
+            vec![(
+                source.clone(),
+                assets.amount_by_and_cents(2, 1300).expect("amount"),
+            )],
             vec![
-                (dest.clone(), assets.amount(2, 1250).expect("amount")),
-                (fee.clone(), assets.amount(2, 50).expect("amount")),
+                (
+                    dest.clone(),
+                    assets.amount_by_and_cents(2, 1250).expect("amount"),
+                ),
+                (
+                    fee.clone(),
+                    assets.amount_by_and_cents(2, 50).expect("amount"),
+                ),
             ],
         )
         .await
@@ -214,7 +290,7 @@ async fn balance_decreases_while_pending_spending_and_failed() {
         .clone();
 
     assert_eq!(
-        vec![assets.amount(2, 1700).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
     assert!(ledger.get_balance(&dest).await.expect("balance").is_empty());
@@ -226,7 +302,7 @@ async fn balance_decreases_while_pending_spending_and_failed() {
         .expect("valid tx");
 
     assert_eq!(
-        vec![assets.amount(2, 1700).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
     assert!(ledger.get_balance(&dest).await.expect("balance").is_empty());
@@ -242,7 +318,7 @@ async fn balance_decreases_while_pending_spending_and_failed() {
     );
 
     assert_eq!(
-        vec![assets.amount(2, 1700).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
     assert!(ledger.get_balance(&dest).await.expect("balance").is_empty());
@@ -254,7 +330,7 @@ async fn balance_decreases_while_pending_spending_and_failed() {
         .expect("valid");
 
     assert_eq!(
-        vec![assets.amount(2, 3000).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 3000).expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
     assert!(ledger.get_balance(&dest).await.expect("balance").is_empty());

utxo/src/tests/negative_deposit.rs

@@ -9,12 +9,22 @@ async fn negative_deposit_prevent_spending() {
     let (assets, ledger) = get_instance().await;
 
     // Deposit some money
-    deposit(&ledger, &source, assets.amount(2, 5000).expect("amount")).await;
+    deposit(
+        &ledger,
+        &source,
+        assets.amount_by_and_cents(2, 5000).expect("amount"),
+    )
+    .await;
     // Take money of source's account
-    deposit(&ledger, &source, assets.amount(2, -10000).expect("amount")).await;
+    deposit(
+        &ledger,
+        &source,
+        assets.amount_by_and_cents(2, -10000).expect("amount"),
+    )
+    .await;
 
     assert_eq!(
-        vec![assets.amount(2, -5000).expect("amount")],
+        vec![assets.amount_by_and_cents(2, -5000).expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
 
@@ -25,10 +35,19 @@ async fn negative_deposit_prevent_spending() {
             .new_transaction(
                 "Exchange one".to_owned(),
                 Status::Settled,
-                vec![(source.clone(), assets.amount(2, 1000).expect("amount"))],
+                vec![(
+                    source.clone(),
+                    assets.amount_by_and_cents(2, 1000).expect("amount")
+                )],
                 vec![
-                    (dest.clone(), assets.amount(2, 950).expect("amount")),
-                    (fee.clone(), assets.amount(2, 50).expect("amount")),
+                    (
+                        dest.clone(),
+                        assets.amount_by_and_cents(2, 950).expect("amount")
+                    ),
+                    (
+                        fee.clone(),
+                        assets.amount_by_and_cents(2, 50).expect("amount")
+                    ),
                 ],
             )
             .await
@@ -45,12 +64,22 @@ async fn negative_deposit_prevent_spending_payback() {
     let (assets, ledger) = get_instance().await;
 
     // Deposit some money
-    deposit(&ledger, &source, assets.amount(2, 5000).expect("amount")).await;
+    deposit(
+        &ledger,
+        &source,
+        assets.amount_by_and_cents(2, 5000).expect("amount"),
+    )
+    .await;
     // Take money of source's account
-    deposit(&ledger, &source, assets.amount(2, -10000).expect("amount")).await;
+    deposit(
+        &ledger,
+        &source,
+        assets.amount_by_and_cents(2, -10000).expect("amount"),
+    )
+    .await;
 
     assert_eq!(
-        vec![assets.amount(2, -5000).expect("amount")],
+        vec![assets.amount_by_and_cents(2, -5000).expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
 
@@ -61,10 +90,19 @@ async fn negative_deposit_prevent_spending_payback() {
             .new_transaction(
                 "Exchange one".to_owned(),
                 Status::Settled,
-                vec![(source.clone(), assets.amount(2, 1000).expect("amount"))],
+                vec![(
+                    source.clone(),
+                    assets.amount_by_and_cents(2, 1000).expect("amount")
+                )],
                 vec![
-                    (dest.clone(), assets.amount(2, 950).expect("amount")),
-                    (fee.clone(), assets.amount(2, 50).expect("amount")),
+                    (
+                        dest.clone(),
+                        assets.amount_by_and_cents(2, 950).expect("amount")
+                    ),
+                    (
+                        fee.clone(),
+                        assets.amount_by_and_cents(2, 50).expect("amount")
+                    ),
                 ],
             )
             .await
@@ -73,31 +111,45 @@ async fn negative_deposit_prevent_spending_payback() {
     );
 
     // Payback the debt
-    deposit(&ledger, &source, assets.amount(2, 15000).expect("amount")).await;
+    deposit(
+        &ledger,
+        &source,
+        assets.amount_by_and_cents(2, 15000).expect("amount"),
+    )
+    .await;
 
     ledger
         .new_transaction(
             "Exchange one".to_owned(),
             Status::Settled,
-            vec![(source.clone(), assets.amount(2, 1000).expect("amount"))],
+            vec![(
+                source.clone(),
+                assets.amount_by_and_cents(2, 1000).expect("amount"),
+            )],
             vec![
-                (dest.clone(), assets.amount(2, 950).expect("amount")),
-                (fee.clone(), assets.amount(2, 50).expect("amount")),
+                (
+                    dest.clone(),
+                    assets.amount_by_and_cents(2, 950).expect("amount"),
+                ),
+                (
+                    fee.clone(),
+                    assets.amount_by_and_cents(2, 50).expect("amount"),
+                ),
             ],
         )
         .await
         .expect("valid tx");
 
     assert_eq!(
-        vec![assets.amount(2, 950).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 950).expect("amount")],
         ledger.get_balance(&dest).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount(2, 50).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 50).expect("amount")],
         ledger.get_balance(&fee).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount(2, 9000).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 9000).expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
 }

utxo/src/tests/withdrawal.rs

@@ -8,11 +8,21 @@ async fn deposit_and_transfer_and_withdrawal() {
     let fee = "fee".parse::<AccountId>().expect("account");
     let (assets, ledger) = get_instance().await;
 
-    deposit(&ledger, &source, assets.amount(2, 1000).expect("amount")).await;
-    deposit(&ledger, &source, assets.amount(2, 2000).expect("amount")).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(2, 3000).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 3000).expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
 
@@ -20,25 +30,34 @@ async fn deposit_and_transfer_and_withdrawal() {
         .new_transaction(
             "Exchange one".to_owned(),
             Status::Settled,
-            vec![(source.clone(), assets.amount(2, 1300).expect("amount"))],
+            vec![(
+                source.clone(),
+                assets.amount_by_and_cents(2, 1300).expect("amount"),
+            )],
             vec![
-                (dest.clone(), assets.amount(2, 1250).expect("amount")),
-                (fee.clone(), assets.amount(2, 50).expect("amount")),
+                (
+                    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(2, 1700).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount(2, 1250).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 1250).expect("amount")],
         ledger.get_balance(&dest).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount(2, 50).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 50).expect("amount")],
         ledger.get_balance(&fee).await.expect("balance")
     );
 
@@ -46,7 +65,7 @@ async fn deposit_and_transfer_and_withdrawal() {
         &ledger,
         &source,
         Status::Settled,
-        assets.amount(2, 1700).expect("amount")
+        assets.amount_by_and_cents(2, 1700).expect("amount")
     )
     .await
     .is_ok());
@@ -57,11 +76,11 @@ async fn deposit_and_transfer_and_withdrawal() {
         .expect("balance")
         .is_empty());
     assert_eq!(
-        vec![assets.amount(2, 1250).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 1250).expect("amount")],
         ledger.get_balance(&dest).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount(2, 50).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 50).expect("amount")],
         ledger.get_balance(&fee).await.expect("balance")
     );
 }
@@ -73,11 +92,21 @@ async fn fail_to_overwithdrawal() {
     let fee = "fee".parse::<AccountId>().expect("account");
     let (assets, ledger) = get_instance().await;
 
-    deposit(&ledger, &source, assets.amount(2, 1000).expect("amount")).await;
-    deposit(&ledger, &source, assets.amount(2, 2000).expect("amount")).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(2, 3000).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 3000).expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
 
@@ -85,25 +114,34 @@ async fn fail_to_overwithdrawal() {
         .new_transaction(
             "Exchange one".to_owned(),
             Status::Settled,
-            vec![(source.clone(), assets.amount(2, 1300).expect("amount"))],
+            vec![(
+                source.clone(),
+                assets.amount_by_and_cents(2, 1300).expect("amount"),
+            )],
             vec![
-                (dest.clone(), assets.amount(2, 1250).expect("amount")),
-                (fee.clone(), assets.amount(2, 50).expect("amount")),
+                (
+                    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(2, 1700).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount(2, 1250).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 1250).expect("amount")],
         ledger.get_balance(&dest).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount(2, 50).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 50).expect("amount")],
         ledger.get_balance(&fee).await.expect("balance")
     );
 
@@ -111,21 +149,21 @@ async fn fail_to_overwithdrawal() {
         &ledger,
         &source,
         Status::Settled,
-        assets.amount(2, 170000).expect("amount")
+        assets.amount_by_and_cents(2, 170000).expect("amount")
     )
     .await
     .is_err());
 
     assert_eq!(
-        vec![assets.amount(2, 1700).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount(2, 1250).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 1250).expect("amount")],
         ledger.get_balance(&dest).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount(2, 50).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 50).expect("amount")],
         ledger.get_balance(&fee).await.expect("balance")
     );
 }
@@ -137,11 +175,21 @@ async fn cancelled_withdrawal() {
     let fee = "fee".parse::<AccountId>().expect("account");
     let (assets, ledger) = get_instance().await;
 
-    deposit(&ledger, &source, assets.amount(2, 1000).expect("amount")).await;
-    deposit(&ledger, &source, assets.amount(2, 2000).expect("amount")).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(2, 3000).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 3000).expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
 
@@ -149,25 +197,34 @@ async fn cancelled_withdrawal() {
         .new_transaction(
             "Exchange one".to_owned(),
             Status::Settled,
-            vec![(source.clone(), assets.amount(2, 1300).expect("amount"))],
+            vec![(
+                source.clone(),
+                assets.amount_by_and_cents(2, 1300).expect("amount"),
+            )],
             vec![
-                (dest.clone(), assets.amount(2, 1250).expect("amount")),
-                (fee.clone(), assets.amount(2, 50).expect("amount")),
+                (
+                    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(2, 1700).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount(2, 1250).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 1250).expect("amount")],
         ledger.get_balance(&dest).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount(2, 50).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 50).expect("amount")],
         ledger.get_balance(&fee).await.expect("balance")
     );
 
@@ -175,7 +232,7 @@ async fn cancelled_withdrawal() {
         &ledger,
         &source,
         Status::Pending,
-        assets.amount(2, 1700).expect("amount"),
+        assets.amount_by_and_cents(2, 1700).expect("amount"),
     )
     .await
     .expect("valid tx");
@@ -186,11 +243,11 @@ async fn cancelled_withdrawal() {
         .expect("balance")
         .is_empty());
     assert_eq!(
-        vec![assets.amount(2, 1250).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 1250).expect("amount")],
         ledger.get_balance(&dest).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount(2, 50).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 50).expect("amount")],
         ledger.get_balance(&fee).await.expect("balance")
     );
 
@@ -200,16 +257,16 @@ async fn cancelled_withdrawal() {
         .expect("valid tx");
 
     assert_eq!(
-        vec![assets.amount(2, 1700).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
 
     assert_eq!(
-        vec![assets.amount(2, 1250).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 1250).expect("amount")],
         ledger.get_balance(&dest).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount(2, 50).expect("amount")],
+        vec![assets.amount_by_and_cents(2, 50).expect("amount")],
         ledger.get_balance(&fee).await.expect("balance")
     );
 }
@@ -219,15 +276,20 @@ async fn negative_withdrawal() {
     let source = "account1".parse::<AccountId>().expect("account");
     let (assets, ledger) = get_instance().await;
 
-    deposit(&ledger, &source, assets.amount(2, -1000).expect("amount")).await;
+    deposit(
+        &ledger,
+        &source,
+        assets.amount_by_and_cents(2, -1000).expect("amount"),
+    )
+    .await;
 
     assert_eq!(
-        vec![assets.amount(2, -1000).expect("amount")],
+        vec![assets.amount_by_and_cents(2, -1000).expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
 
     assert_eq!(
-        vec![assets.amount(2, -1000).expect("amount")],
+        vec![assets.amount_by_and_cents(2, -1000).expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
 
@@ -235,7 +297,7 @@ async fn negative_withdrawal() {
         &ledger,
         &source,
         Status::Settled,
-        assets.amount(2, -1000).expect("amount"),
+        assets.amount_by_and_cents(2, -1000).expect("amount"),
     )
     .await
     .is_err());
@@ -244,7 +306,7 @@ async fn negative_withdrawal() {
         &ledger,
         &source,
         Status::Settled,
-        assets.amount(2, -1).expect("amount"),
+        assets.amount_by_and_cents(2, -1).expect("amount"),
     )
     .await
     .is_err());
@@ -253,7 +315,7 @@ async fn negative_withdrawal() {
         &ledger,
         &source,
         Status::Settled,
-        assets.amount(2, 0).expect("amount"),
+        assets.amount_by_and_cents(2, 0).expect("amount"),
     )
     .await
     .is_err());
@@ -262,13 +324,13 @@ async fn negative_withdrawal() {
         &ledger,
         &source,
         Status::Settled,
-        assets.amount(2, 10).expect("amount"),
+        assets.amount_by_and_cents(2, 10).expect("amount"),
     )
     .await
     .is_err());
 
     assert_eq!(
-        vec![assets.amount(2, -1000).expect("amount")],
+        vec![assets.amount_by_and_cents(2, -1000).expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
 }

utxo/src/transaction/from_db.rs

@@ -1,3 +1,4 @@
+use super::Type;
 use crate::{Payment, Status, TransactionId};
 use chrono::{DateTime, Utc};
 
@@ -6,7 +7,8 @@ pub struct Transaction {
     pub spend: Vec<Payment>,
     pub create: Vec<Payment>,
     pub reference: String,
+    pub typ: Type,
     pub status: Status,
-    pub created_at: DateTime<Utc>, 
-    pub updated_at: DateTime<Utc>, 
+    pub created_at: DateTime<Utc>,
+    pub updated_at: DateTime<Utc>,
 }

utxo/src/transaction/inner.rs

@@ -42,10 +42,9 @@ pub struct Transaction {
     spend: Vec<Payment>,
     #[allow(dead_code)]
     reference: String,
+    typ: Type,
     create: Vec<Payment>,
     status: Status,
-    #[serde(skip)]
-    is_external_operation: bool,
     #[serde(with = "ts_milliseconds")]
     created_at: DateTime<Utc>,
     #[serde(with = "ts_milliseconds")]
@@ -73,8 +72,8 @@ impl Transaction {
             id,
             spend,
             create: vec![],
+            typ: Type::Withdrawal,
             reference,
-            is_external_operation: true,
             status,
             created_at: Utc::now(),
             updated_at: Utc::now(),
@@ -113,7 +112,7 @@ impl Transaction {
             spend: vec![],
             create,
             reference,
-            is_external_operation: true,
+            typ: Type::Deposit,
             status,
             created_at: Utc::now(),
             updated_at: Utc::now(),
@@ -123,6 +122,7 @@ impl Transaction {
     pub async fn new(
         reference: String,
         status: Status,
+        typ: Type,
         spend: Vec<Payment>,
         pay_to: Vec<(AccountId, Amount)>,
     ) -> Result<Transaction, Error> {
@@ -166,8 +166,8 @@ impl Transaction {
             id,
             reference,
             spend,
+            typ,
             create,
-            is_external_operation: false,
             status,
             created_at: Utc::now(),
             updated_at: Utc::now(),
@@ -270,7 +270,7 @@ impl Transaction {
 
         self.check_no_negative_amounts_are_spent(&debit)?;
 
-        if self.is_external_operation {
+        if !self.typ.is_transaction() {
             // We don't care input/output balance in external operations
             // (withdrawals/deposits), because these operations are inbalanced
             return Ok(());
@@ -327,6 +327,10 @@ impl Transaction {
         &self.status
     }
 
+    pub fn typ(&self) -> &Type {
+        &self.typ
+    }
+
     pub fn reference(&self) -> &str {
         &self.reference
     }
@@ -356,15 +360,15 @@ impl Transaction {
         for payment in self.create.iter() {
             batch.store_new_payment(payment).await?;
             batch
-                .relate_account_to_transaction(&self.id, &payment.to)
+                .relate_account_to_transaction(&self, &payment.to)
                 .await?;
         }
-        for input in self.spend.iter_mut() {
+        for input in self.spend.iter() {
             batch
                 .spend_payment(&input.id, self.status.clone(), &self.id)
                 .await?;
             batch
-                .relate_account_to_transaction(&self.id, &input.to)
+                .relate_account_to_transaction(&self, &input.to)
                 .await?;
         }
         batch.commit().await?;
@@ -378,7 +382,7 @@ impl TryFrom<from_db::Transaction> for Transaction {
     fn try_from(value: from_db::Transaction) -> Result<Self, Self::Error> {
         let tx = Transaction {
             id: value.id,
-            is_external_operation: value.spend.is_empty() || value.create.is_empty(),
+            typ: value.typ,
             spend: value.spend,
             create: value.create,
             reference: value.reference,

utxo/src/transaction/mod.rs

@@ -1,5 +1,6 @@
 mod error;
 pub mod from_db;
 mod inner;
+mod typ;
 
-pub use self::{error::Error, inner::Transaction};
+pub use self::{error::Error, inner::Transaction, typ::Type};

utxo/src/transaction/typ.rs

@@ -0,0 +1,52 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+    #[error("Invalid status: {0}")]
+    InvalidStatus(u32),
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
+pub enum Type {
+    Deposit,
+    Withdrawal,
+    Transaction,
+    Internal,
+}
+
+impl Type {
+    #[inline]
+    pub fn is_transaction(&self) -> bool {
+        matches!(self, Self::Transaction | Self::Internal)
+    }
+}
+
+impl TryFrom<u32> for Type {
+    type Error = Error;
+    fn try_from(value: u32) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(Self::Transaction),
+            1 => Ok(Self::Deposit),
+            2 => Ok(Self::Withdrawal),
+            1000 => Ok(Self::Internal),
+            _ => Err(Error::InvalidStatus(value)),
+        }
+    }
+}
+
+impl From<Type> for u32 {
+    fn from(value: Type) -> Self {
+        (&value).into()
+    }
+}
+
+impl From<&Type> for u32 {
+    fn from(value: &Type) -> Self {
+        match value {
+            Type::Transaction => 0,
+            Type::Deposit => 1,
+            Type::Withdrawal => 2,
+            Type::Internal => 1000,
+        }
+    }
+}