WIP: Updating docs and struct

This is a commit work towards an append only data model.

Updates are not allowed into this DB for obvious reasons, instead a new
revision is allowed to be published, always keeping a record of the previous
state of the transaction.

Although a transaction updates many internal fields, the whole transaction is
updated as a single entity

Cargo.lock

@@ -1035,9 +1035,9 @@ checksum = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7"
 
 [[package]]
 name = "futures"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23342abe12aba583913b2e62f22225ff9c950774065e4bfb61a19cd9770fec40"
+checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0"
 dependencies = [
  "futures-channel",
  "futures-core",
@@ -1050,9 +1050,9 @@ dependencies = [
 
 [[package]]
 name = "futures-channel"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "955518d47e09b25bbebc7a18df10b81f0c766eaf4c4f1cccef2fca5f2a4fb5f2"
+checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78"
 dependencies = [
  "futures-core",
  "futures-sink",
@@ -1060,15 +1060,15 @@ dependencies = [
 
 [[package]]
 name = "futures-core"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bca583b7e26f571124fe5b7561d49cb2868d79116cfa0eefce955557c6fee8c"
+checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d"
 
 [[package]]
 name = "futures-executor"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ccecee823288125bd88b4d7f565c9e58e41858e47ab72e8ea2d64e93624386e0"
+checksum = "a576fc72ae164fca6b9db127eaa9a9dda0d61316034f33a0a0d4eda41f02b01d"
 dependencies = [
  "futures-core",
  "futures-task",
@@ -1088,9 +1088,9 @@ dependencies = [
 
 [[package]]
 name = "futures-io"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fff74096e71ed47f8e023204cfd0aa1289cd54ae5430a9523be060cdb849964"
+checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1"
 
 [[package]]
 name = "futures-lite"
@@ -1109,9 +1109,9 @@ dependencies = [
 
 [[package]]
 name = "futures-macro"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89ca545a94061b6365f2c7355b4b32bd20df3ff95f02da9329b34ccc3bd6ee72"
+checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1120,21 +1120,21 @@ dependencies = [
 
 [[package]]
 name = "futures-sink"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f43be4fe21a13b9781a69afa4985b0f6ee0e1afab2c6f454a8cf30e2b2237b6e"
+checksum = "9fb8e00e87438d937621c1c6269e53f536c14d3fbd6a042bb24879e57d474fb5"
 
 [[package]]
 name = "futures-task"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76d3d132be6c0e6aa1534069c705a74a5997a356c0dc2f86a47765e5617c5b65"
+checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004"
 
 [[package]]
 name = "futures-util"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26b01e40b772d54cf6c6d721c1d1abd0647a0106a12ecaa1c186273392a69533"
+checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48"
 dependencies = [
  "futures-channel",
  "futures-core",
@@ -2284,12 +2284,6 @@ dependencies = [
 ]
 
 [[package]]
-name = "rustversion"
-version = "1.0.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4"
-
-[[package]]
 name = "ryu"
 version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -2821,25 +2815,6 @@ dependencies = [
 ]
 
 [[package]]
-name = "strum"
-version = "0.25.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "290d54ea6f91c969195bdbcd7442c8c2a2ba87da8bf60a7ee86a235d4bc1e125"
-
-[[package]]
-name = "strum_macros"
-version = "0.25.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad8d03b598d3d0fff69bf533ee3ef19b8eeb342729596df84bcc7e1f96ec4059"
-dependencies = [
- "heck",
- "proc-macro2",
- "quote",
- "rustversion",
- "syn 2.0.37",
-]
-
-[[package]]
 name = "subtle"
 version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -3203,8 +3178,6 @@ dependencies = [
  "serde",
  "sha2",
  "sqlx",
- "strum",
- "strum_macros",
  "thiserror",
  "tokio 1.32.0",
 ]

client.js

@@ -1,94 +1,100 @@
 
+const util = require("util");
 const addr1 = "foo";
 const addr2 = "bar";
 const fee = "fee";
 const percentage = 0.005;
 
+function dbg(obj) {
+  console.log(util.inspect(obj, false, null, true /* enable colors */))
+}
+
 async function deposit(account, amount, asset) {
-	const response = (await fetch("http://127.0.0.1:8080/deposit", {
-		method: "POST",
-		headers: {
-			"Content-Type": "application/json",
-		},
-		body: JSON.stringify({
-			memo: "deposit",
-			account,
-			amount: amount.toString(),
-			status: 'pending',
-			asset,
-		})
-	}));
-	return response.json();
+  const response = (await fetch("http://127.0.0.1:8080/deposit", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      memo: "deposit",
+      account,
+      amount: amount.toString(),
+      asset,
+      status: 'pending',
+    })
+  }));
+  return response.json();
 }
 
 async function trade(amount, asset, from, amount_to, asset_to, to) {
-	const response = (await fetch("http://127.0.0.1:8080/tx", {
-		method: "POST",
-		headers: {
-			"Content-Type": "application/json",
-		},
-		body: JSON.stringify({
-			memo: "trade",
-			debit: [
-				{
-					account: from,
-					amount: amount.toString(),
-					asset,
-				},
-				{
-					account: to,
-					amount: amount_to.toString(),
-					asset: asset_to,
-				}
-			],
-			credit: [
-				{
-					account: to,
-					amount: (amount * (1 - percentage)).toString(),
-					asset,
-				},
-				{
-					account: from,
-					amount: amount_to.toString(),
-					asset: asset_to,
-				},
-				{
-					account: fee,
-					amount: (amount * percentage).toString(),
-					asset,
-				}
-			],
-			status: 'pending',
-			asset,
-		})
-	}));
-	return response.json();
+  const response = (await fetch("http://127.0.0.1:8080/tx", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      memo: "trade",
+      debit: [
+        {
+          account: from,
+          amount: amount.toString(),
+          asset
+        },
+        {
+          account: to,
+          amount: amount_to.toString(),
+          asset: asset_to,
+        }
+      ],
+      credit: [
+        {
+          account: to,
+          amount: (amount * (1 - percentage)).toString(),
+          asset
+        },
+        {
+          account: from,
+          amount: amount_to.toString(),
+          asset: asset_to
+        },
+        {
+          account: fee,
+          amount: (amount * percentage).toString(),
+          asset
+        }
+      ],
+      status: 'pending',
+      asset,
+    })
+  }));
+  return response.json();
 }
 
 async function change_status(id, s_status) {
-	const response = (await fetch(`http://127.0.0.1:8080/${id}`, {
-		method: "POST",
-		headers: {
-			"Content-Type": "application/json",
-		},
-		body: JSON.stringify({
-			status: s_status,
-			memo: `change status to ${s_status}`,
-		})
-	}));
-	return response.json();
+  const response = (await fetch(`http://127.0.0.1:8080/${id}`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      status: s_status,
+      memo: `change status to ${s_status}`,
+    })
+  }));
+  return response.json();
 }
 
 async function test() {
-	let d = (await deposit(addr1, 100, "BTC"));
-	console.log(await change_status(d.id, 'settled'));
-	d = (await deposit(addr2, 1000000, "USD"));
-	console.log(await change_status(d.id, 'settled'));
+  let d = (await deposit(addr1, 100, "BTC/8"));
+  dbg(d);
+  dbg(await change_status(d.id, 'settled'));
+  d = (await deposit(addr2, 1000000, "USD/4"));
+  dbg(await change_status(d.id, 'settled'));
 
-	const t = await trade(1, "BTC", addr1, 26751.11, "USD", addr2);
-	console.log(t);
-	console.log(await change_status(t.id, 'processing',));
-	console.log(await change_status(t.id, 'settled'));
+  const t = await trade(1, "BTC/8", addr1, 26751.11, "USD/4", addr2);
+  dbg(t);
+  dbg(await change_status(t.id, 'processing',));
+  dbg(await change_status(t.id, 'settled'));
 }
 
 test()

src/main.rs

@@ -4,21 +4,20 @@ use actix_web::{
 };
 use serde::{Deserialize, Serialize};
 use serde_json::json;
-use std::sync::Arc;
-use verax::{AccountId, AnyId, AssetDefinition, AssetManager, Status, TransactionId, Type};
+use verax::{AccountId, AnyAmount, AnyId, Asset, Status, TransactionId, Type};
 
 #[derive(Deserialize)]
 pub struct Movement {
     pub account: AccountId,
-    pub amount: String,
-    pub asset: String,
+    #[serde(flatten)]
+    pub amount: AnyAmount,
 }
 
 #[derive(Deserialize)]
 pub struct Deposit {
     pub account: AccountId,
-    pub amount: String,
-    pub asset: String,
+    #[serde(flatten)]
+    pub amount: AnyAmount,
     pub memo: String,
     pub status: Status,
 }
@@ -28,10 +27,14 @@ impl Deposit {
         self,
         ledger: &Ledger,
     ) -> Result<verax::Transaction, verax::Error> {
-        let amount = ledger._inner.parse_amount(&self.asset, &self.amount)?;
         ledger
             ._inner
-            .deposit(&self.account, amount, self.status, self.memo)
+            .deposit(
+                &self.account,
+                self.amount.try_into()?,
+                self.status,
+                self.memo,
+            )
             .await
     }
 }
@@ -71,23 +74,13 @@ impl Transaction {
         let from = self
             .debit
             .into_iter()
-            .map(|x| {
-                ledger
-                    ._inner
-                    .parse_amount(&x.asset, &x.amount)
-                    .map(|amount| (x.account, amount))
-            })
+            .map(|x| x.amount.try_into().map(|amount| (x.account, amount)))
             .collect::<Result<Vec<_>, _>>()?;
 
         let to = self
             .credit
             .into_iter()
-            .map(|x| {
-                ledger
-                    ._inner
-                    .parse_amount(&x.asset, &x.amount)
-                    .map(|amount| (x.account, amount))
-            })
+            .map(|x| x.amount.try_into().map(|amount| (x.account, amount)))
             .collect::<Result<Vec<_>, _>>()?;
 
         ledger
@@ -106,35 +99,21 @@ struct Item {
 #[derive(Serialize)]
 struct AccountResponse {
     amount: String,
-    #[serde(
-        serialize_with = "verax::serialize_arc_str",
-        deserialize_with = "verax::deserialize_arc_str"
-    )]
-    asset: Arc<str>,
+    asset: Asset,
 }
 
 #[get("/balance/{id}")]
 async fn get_balance(info: web::Path<AccountId>, ledger: web::Data<Ledger>) -> impl Responder {
-    let asset_manager = ledger._inner.asset_manager();
     match ledger._inner.get_balance(&info.0).await {
-        Ok(balances) => {
-            match balances
+        Ok(balances) => HttpResponse::Ok().json(
+            balances
                 .into_iter()
-                .map(|amount| {
-                    asset_manager
-                        .get_name(amount.asset().id)
-                        .map(|asset| AccountResponse {
-                            amount: amount.to_string(),
-                            asset,
-                        })
+                .map(|amount| AccountResponse {
+                    amount: amount.to_string(),
+                    asset: amount.asset().clone(),
                 })
-                .collect::<Result<Vec<_>, _>>()
-            {
-                Ok(balances) => HttpResponse::Ok().json(balances),
-                Err(err) => HttpResponse::InternalServerError()
-                    .json(json!({ "text": err.to_string(), "err": err})),
-            }
-        }
+                .collect::<Vec<_>>(),
+        ),
         Err(err) => HttpResponse::BadRequest().json(json!({ "text": err.to_string(), "err": err})),
     }
 }
@@ -231,11 +210,6 @@ async fn main() -> std::io::Result<()> {
     }
     env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
 
-    let asset_manager = AssetManager::new(vec![
-        AssetDefinition::new(1, "BTC", 8),
-        AssetDefinition::new(2, "USD", 4),
-    ]);
-
     let settings = "sqlite:./test.db"
         .parse::<verax::storage::sqlite::SqliteConnectOptions>()
         .expect("valid settings")
@@ -246,13 +220,13 @@ async fn main() -> std::io::Result<()> {
         .await
         .expect("pool");
 
-    let storage = verax::storage::SQLite::new(pool.clone(), asset_manager.clone());
+    let storage = verax::storage::SQLite::new(pool.clone());
     storage.setup().await.expect("setup");
 
     HttpServer::new(move || {
-        let inner_storage = verax::storage::SQLite::new(pool.clone(), asset_manager.clone());
+        let inner_storage = verax::storage::SQLite::new(pool.clone());
         let storage = verax::storage::Cache::new(inner_storage);
-        let ledger = verax::Ledger::new(storage, asset_manager.clone());
+        let ledger = verax::Ledger::new(storage.into());
         App::new()
             .wrap(Logger::default())
             .app_data(web::Data::new(Ledger { _inner: ledger }))

utxo/Cargo.toml

@@ -7,7 +7,7 @@ edition = "2021"
 async-trait = "0.1.73"
 bincode = { version = "1.3.3", features = ["i128"] }
 chrono = { version = "0.4.31", features = ["serde"] }
-futures = "0.3.28"
+futures = { version = "0.3.30", optional = true }
 hex = "0.4.3"
 serde = { version = "1.0.188", features = ["derive"] }
 sha2 = "0.10.7"
@@ -18,13 +18,12 @@ sqlx = { version = "0.7.1", features = [
     "sqlite",
     "chrono",
 ], optional = true }
-strum = "0.25.0"
-strum_macros = "0.25.2"
 thiserror = "1.0.48"
 tokio = { version = "1.32.0", features = ["full"] }
 
 [dev-dependencies]
 rand = "0.8.5"
+futures = "0.3.30"
 sqlx = { version = "0.7.1", features = [
     "runtime-tokio",
     "runtime-async-std-native-tls",
@@ -35,4 +34,4 @@ sqlx = { version = "0.7.1", features = [
 
 [features]
 default = []
-sqlite = ["sqlx"]
+sqlite = ["sqlx", "futures"]

utxo/src/account_id.rs

@@ -1,24 +0,0 @@
-use std::fmt::Display;
-
-use serde::Serialize;
-
-#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Serialize)]
-pub struct AccountId(pub [u8; 32]);
-
-impl AccountId {
-    pub fn new() -> Self {
-        Self([0; 32])
-    }
-}
-
-impl Display for AccountId {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", hex::encode(self.0))
-    }
-}
-
-impl AsRef<[u8]> for AccountId {
-    fn as_ref(&self) -> &[u8] {
-        &self.0
-    }
-}

utxo/src/amount.rs

@@ -1,5 +1,5 @@
 use crate::Asset;
-use serde::{ser::SerializeMap, Serialize, Serializer};
+use serde::{de, Deserialize, Serialize, Serializer};
 
 /// The raw storage for cents, the more the better
 pub type AmountCents = i128;
@@ -8,6 +8,42 @@ pub type AmountCents = i128;
 pub enum Error {
     #[error("{0} is not a valid number")]
     NoANumber(String),
+
+    #[error("Invalid asset name: {0}")]
+    InvalidAssetName(String),
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+/// Human amount
+///
+/// This amount is used to represent the amount in a human readable way.  It is not being used
+/// internally but it is defined to be used by any external interface.
+pub struct HumanAmount {
+    asset: Asset,
+    amount: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(untagged)]
+/// Any amount
+///
+/// This amount will parse/encode any amount, either in cents or in human readable format.
+pub enum AnyAmount {
+    /// Amount in cents
+    Cent(Amount),
+    /// Amount in human readable format
+    Human(HumanAmount),
+}
+
+impl TryInto<Amount> for AnyAmount {
+    type Error = Error;
+
+    fn try_into(self) -> Result<Amount, Self::Error> {
+        match self {
+            Self::Cent(a) => Ok(a),
+            Self::Human(h) => h.asset.from_human(&h.amount),
+        }
+    }
 }
 
 /// Amount
@@ -24,25 +60,31 @@ pub enum Error {
 /// operation.
 ///
 ///
-/// The `cents` and `Asset.id` must be used to store amounts in the storage
+/// The `cents` and `Asset` must be used to store amounts in the storage
 /// layer. Float or string representations should be used to display
-#[derive(Clone, Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
 pub struct Amount {
     asset: Asset,
+    #[serde(
+        deserialize_with = "deserialize_string_to_amount",
+        serialize_with = "serialize_amount_as_string"
+    )]
     cents: AmountCents,
 }
 
-impl Serialize for Amount {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let amount = self.to_string();
-        let mut s = serializer.serialize_map(Some(2))?;
-        s.serialize_entry("amount", &amount)?;
-        s.serialize_entry("asset", self.asset.name.to_string().as_str())?;
-        s.end()
-    }
+fn deserialize_string_to_amount<'de, D>(deserializer: D) -> Result<AmountCents, D::Error>
+where
+    D: de::Deserializer<'de>,
+{
+    let s = String::deserialize(deserializer)?;
+    s.parse::<AmountCents>().map_err(serde::de::Error::custom)
+}
+
+fn serialize_amount_as_string<S>(value: &AmountCents, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    serializer.serialize_str(&value.to_string())
 }
 
 impl Amount {
@@ -53,7 +95,7 @@ impl Amount {
 
     /// Creates a new amount from a human amount (a floating number serialized
     /// as string to avoid loss precision)
-    pub(crate) fn from_human(asset: Asset, human_amount: &str) -> Result<Self, Error> {
+    pub fn from_human(asset: Asset, human_amount: &str) -> Result<Self, Error> {
         let mut dot_at = None;
         for (pos, i) in human_amount.chars().enumerate() {
             match i {
@@ -146,22 +188,14 @@ mod test {
 
     #[test]
     fn dollar() {
-        let usd = Asset {
-            id: 1,
-            precision: 4,
-            name: "BTC".into(),
-        };
+        let usd: Asset = "USD/4".parse().expect("asset");
         let amount = usd.new_amount(1022100);
         assert_eq!(amount.to_string(), "102.21");
     }
 
     #[test]
     fn bitcoin() {
-        let btc = Asset {
-            id: 1,
-            precision: 8,
-            name: "BTC".into(),
-        };
+        let btc: Asset = "BTC/8".parse().expect("asset");
         assert_eq!(btc.new_amount(1022100).to_string(), "0.010221");
         assert_eq!(btc.new_amount(10).to_string(), "0.0000001");
         assert_eq!(btc.new_amount(10000000).to_string(), "0.1");
@@ -178,11 +212,7 @@ mod test {
 
     #[test]
     fn from_human() {
-        let btc = Asset {
-            id: 1,
-            precision: 8,
-            name: "BTC".into(),
-        };
+        let btc: Asset = "BTC/8".parse().expect("asset");
         let parsed_amount = Amount::from_human(btc.clone(), "0.1").expect("valid amount");
         assert_eq!(parsed_amount.to_string(), "0.1");
         let parsed_amount = Amount::from_human(btc.clone(), "-0.1").expect("valid amount");

utxo/src/asset.rs

@@ -1,40 +1,130 @@
-use crate::{amount::AmountCents, Amount};
-use serde::{Deserialize, Serialize};
-use std::{fmt::Display, sync::Arc};
-
-pub type AssetId = u32;
-
-/// An asset
-///
-/// The asset definition is just a u32 number, which is meaningless for the
-/// code, as long as each asset has an unique id.
-///
-/// The asset struct also has a precision, which is a u8 number (from 0-255)
-/// which is used by amount when converting the inner_amount to a human readable
-/// format.
-#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
+use crate::{
+    amount::{AmountCents, Error},
+    Amount, MaxLengthString,
+};
+use serde::{de, Serialize, Serializer};
+use std::{
+    fmt::{self, Display},
+    str::FromStr,
+};
+
+#[derive(Debug, Hash, PartialEq, Eq, Clone)]
+/// An asset type
 pub struct Asset {
-    /// The Asset id
-    pub id: AssetId,
-    #[serde(
-        serialize_with = "crate::serialize_arc_str",
-        deserialize_with = "crate::deserialize_arc_str"
-    )]
     /// The name of the asset
-    pub name: Arc<str>,
-    /// The precision
-    pub(crate) precision: u8,
+    pub name: MaxLengthString<10>,
+    /// The precision of the asset
+    pub precision: u8,
+}
+
+impl FromStr for Asset {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut split = s.splitn(2, '/');
+        let name = split
+            .next()
+            .ok_or_else(|| Error::InvalidAssetName(s.to_owned()))?;
+        let precision = split
+            .next()
+            .ok_or_else(|| Error::InvalidAssetName(s.to_owned()))?
+            .parse::<u8>()
+            .map_err(|_| Error::NoANumber(s.to_owned()))?;
+
+        Ok(Asset {
+            name: MaxLengthString::new(name.to_owned())
+                .map_err(|_| Error::InvalidAssetName(name.to_owned()))?,
+            precision,
+        })
+    }
+}
+
+impl Display for Asset {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}/{}", self.name, self.precision)
+    }
 }
 
 impl Asset {
-    /// Creates a new amount from the asset
+    /// Creates a new amount from a given amount in cents
     pub fn new_amount(&self, cents: AmountCents) -> Amount {
         Amount::new(self.clone(), cents)
     }
+
+    /// Creates a new amount from a human amount (a floating number serialized
+    /// as string to avoid loss precision)
+    pub fn from_human(&self, human_amount: &str) -> Result<Amount, Error> {
+        let mut dot_at = None;
+        for (pos, i) in human_amount.chars().enumerate() {
+            match i {
+                '-' => {
+                    if pos != 0 {
+                        return Err(Error::NoANumber(human_amount.to_owned()));
+                    }
+                }
+                '.' => {
+                    if dot_at.is_some() {
+                        return Err(Error::NoANumber(human_amount.to_owned()));
+                    }
+                    dot_at = Some(pos);
+                }
+                '0'..='9' => {}
+                _ => {
+                    return Err(Error::NoANumber(human_amount.to_owned()));
+                }
+            }
+        }
+
+        let (whole, fractional_part) = if let Some(dot_at) = dot_at {
+            let (whole, fractional_part) = human_amount.split_at(dot_at);
+            (whole, fractional_part[1..].to_owned())
+        } else {
+            (human_amount, "".to_owned())
+        };
+
+        let fractional_part = fractional_part + &"0".repeat(self.precision.into());
+
+        let cents = (whole.to_owned() + &fractional_part[..self.precision.into()])
+            .parse::<AmountCents>()
+            .map_err(|_| Error::NoANumber(format!("{}.{}", whole, fractional_part)))?;
+
+        Ok(Amount::new(self.clone(), cents))
+    }
 }
 
-impl Display for Asset {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.id)
+impl Serialize for Asset {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(&format!("{}/{}", self.name, self.precision))
+    }
+}
+
+struct AssetVisitor;
+
+impl<'de> de::Visitor<'de> for AssetVisitor {
+    type Value = Asset;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str("a string in the format 'name/precision'")
+    }
+
+    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        value
+            .parse::<Self::Value>()
+            .map_err(|e| de::Error::custom(e.to_string()))
+    }
+}
+
+impl<'de> de::Deserialize<'de> for Asset {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: de::Deserializer<'de>,
+    {
+        deserializer.deserialize_str(AssetVisitor)
     }
 }

utxo/src/asset_manager.rs

@@ -1,96 +0,0 @@
-use crate::{amount::AmountCents, asset::AssetId, Amount, Asset, Error};
-use std::{collections::HashMap, sync::Arc};
-
-/// Asset manager
-///
-/// The Verax asset manager is a simple structure that holds the list of
-/// supported assets.
-///
-/// The asset manager is used to convert from human readable amounts to an
-/// internal representation which is safe to use and operate.
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct AssetManager {
-    assets: Arc<HashMap<AssetId, AssetDefinition>>,
-    asset_names: Arc<HashMap<Arc<str>, AssetDefinition>>,
-}
-
-/// The asset definition
-///
-/// It is a simple structure that holds the asset id (an internal number), name
-/// (a human name) and the asset precision.
-#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize)]
-pub struct AssetDefinition {
-    /// The asset definition
-    #[serde(flatten)]
-    pub asset: Asset,
-    #[serde(
-        serialize_with = "crate::serialize_arc_str",
-        deserialize_with = "crate::deserialize_arc_str"
-    )]
-    name: Arc<str>,
-}
-
-impl AssetManager {
-    /// Creates a new instance of the asset manager
-    pub fn new(assets: Vec<AssetDefinition>) -> Self {
-        Self {
-            assets: Arc::new(
-                assets
-                    .iter()
-                    .map(|asset| (asset.asset.id, asset.clone()))
-                    .collect(),
-            ),
-            asset_names: Arc::new(
-                assets
-                    .into_iter()
-                    .map(|asset| (asset.name.clone(), asset))
-                    .collect(),
-            ),
-        }
-    }
-
-    /// Get the name of an asset by their asset id
-    pub fn get_name(&self, id: AssetId) -> Result<Arc<str>, Error> {
-        self.assets
-            .get(&id)
-            .map(|asset| asset.name.clone())
-            .ok_or(Error::AssetIdNotFound(id))
-    }
-
-    /// Get an asset definition by their id
-    pub fn asset(&self, id: AssetId) -> Result<Asset, Error> {
-        self.assets
-            .get(&id)
-            .map(|asset| asset.asset.clone())
-            .ok_or(Error::AssetIdNotFound(id))
-    }
-
-    /// Get an asset definition by their human name
-    pub fn human_amount_by_name(&self, name: &str, human_amount: &str) -> Result<Amount, Error> {
-        Ok(self
-            .asset_names
-            .get(name)
-            .map(|asset| Amount::from_human(asset.asset.clone(), human_amount))
-            .ok_or(Error::AssetNotFound(name.to_owned()))??)
-    }
-
-    /// Get an Amount by their asset Id and cents
-    pub fn amount_by_and_cents(&self, id: AssetId, cents: AmountCents) -> Result<Amount, Error> {
-        self.asset(id).map(|asset| Amount::new(asset, cents))
-    }
-}
-
-impl AssetDefinition {
-    /// Creates a new asset definition
-    pub fn new(id: u32, name: &str, precision: u8) -> Self {
-        let name: Arc<str> = name.into();
-        Self {
-            asset: Asset {
-                id,
-                precision,
-                name: name.clone(),
-            },
-            name,
-        }
-    }
-}

utxo/src/changelog.rs

@@ -1,108 +0,0 @@
-use chrono::{serde::ts_milliseconds, DateTime, Utc};
-use serde::{de::DeserializeOwned, Deserialize, Serialize};
-use sha2::{Digest, Sha256};
-use std::collections::{HashMap, VecDeque};
-
-#[derive(thiserror::Error, Debug, Serialize)]
-pub enum Error {
-    #[error("Missing change {0:?}")]
-    MissingChange(Vec<u8>),
-
-    #[error("Unexpected changes {0:?}")]
-    UnexpectedChanges(Vec<Vec<u8>>),
-
-    #[error("Bincode: {0}")]
-    #[serde(serialize_with = "crate::serialize_error_to_string")]
-    Bincode(#[from] bincode::Error),
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
-#[serde(bound = "T: Serialize + DeserializeOwned")]
-pub struct Changelog<T: DeserializeOwned + Serialize + Send + Sync> {
-    #[serde(skip)]
-    pub previous: Option<Vec<u8>>,
-    #[serde(skip)]
-    pub object_id: Vec<u8>,
-    #[serde(flatten)]
-    pub change: T,
-    #[serde(with = "ts_milliseconds")]
-    pub updated_at: DateTime<Utc>,
-}
-
-impl<T: DeserializeOwned + Serialize + Send + Sync> Changelog<T> {
-    pub fn new(previous: Option<Vec<u8>>, object_id: Vec<u8>, change: T) -> Changelog<T> {
-        Self {
-            previous,
-            object_id,
-            change,
-            updated_at: Utc::now(),
-        }
-    }
-
-    pub fn new_from_db(
-        previous: Option<Vec<u8>>,
-        object_id: Vec<u8>,
-        change: T,
-        created_at: DateTime<Utc>,
-    ) -> Changelog<T> {
-        Self {
-            previous,
-            object_id,
-            change,
-            updated_at: created_at,
-        }
-    }
-
-    pub fn id(&self) -> Result<Vec<u8>, Error> {
-        let mut hasher = Sha256::new();
-        hasher.update(&self.object_id);
-        hasher.update(if let Some(v) = self.previous.as_ref() {
-            v.clone()
-        } else {
-            vec![0, 0]
-        });
-        hasher.update(&bincode::serialize(&self.change)?);
-        hasher.update(&bincode::serialize(&self.updated_at)?);
-        Ok(hasher.finalize().to_vec())
-    }
-}
-
-pub fn sort_changes<T: DeserializeOwned + Serialize + Send + Sync>(
-    changes: Vec<Changelog<T>>,
-    last_change: Vec<u8>,
-) -> Result<Vec<Changelog<T>>, Error> {
-    let mut changes_by_id = changes
-        .into_iter()
-        .map(|a| a.id().map(|id| (id, a)))
-        .collect::<Result<HashMap<Vec<u8>, Changelog<T>>, _>>()?;
-
-    let mut sorted_changes = VecDeque::new();
-
-    let last_change = match changes_by_id.remove(&last_change) {
-        Some(change) => change,
-        None => return Err(Error::MissingChange(last_change)),
-    };
-
-    sorted_changes.push_front(last_change);
-
-    loop {
-        let first_element = sorted_changes.get(0).unwrap();
-        if let Some(id) = first_element.previous.as_ref() {
-            let last_change = match changes_by_id.remove(id) {
-                Some(change) => change,
-                None => return Err(Error::MissingChange(id.clone())),
-            };
-            sorted_changes.push_front(last_change);
-        } else {
-            break;
-        }
-    }
-
-    if !changes_by_id.is_empty() {
-        return Err(Error::UnexpectedChanges(
-            changes_by_id.into_keys().collect(),
-        ));
-    }
-
-    Ok(sorted_changes.into())
-}

utxo/src/config.rs

@@ -0,0 +1,22 @@
+use crate::{status::StatusManager, storage::Storage};
+
+#[derive(Debug)]
+pub struct Config<S>
+where
+    S: Storage + Sync + Send,
+{
+    pub storage: S,
+    pub status: StatusManager,
+}
+
+impl<S> From<S> for Config<S>
+where
+    S: Storage + Sync + Send,
+{
+    fn from(storage: S) -> Self {
+        Self {
+            storage,
+            status: StatusManager::default(),
+        }
+    }
+}

utxo/src/error.rs

@@ -1,4 +1,4 @@
-use crate::{amount, asset::AssetId, storage, transaction, AccountId};
+use crate::{amount, asset::Asset, storage, transaction, AccountId};
 use serde::Serialize;
 
 /// The errors that can happen in the Verax crate
@@ -14,7 +14,7 @@ pub enum Error {
 
     /// The asset is not defined
     #[error("Asset {0} is not defined")]
-    AssetIdNotFound(AssetId),
+    AssetIdNotFound(Asset),
 
     /// The asset is not found
     #[error("Asset {0} is not defined")]
@@ -22,7 +22,7 @@ pub enum Error {
 
     /// The account has not enough balance to perform the operation
     #[error("Not enough funds (asset {1}) for account {0}")]
-    InsufficientBalance(AccountId, AssetId),
+    InsufficientBalance(AccountId, Asset),
 
     /// The amount is invalid
     #[error("Invalid amount: {0}")]

utxo/src/id.rs → utxo/src/id/binary.rs

@@ -1,27 +1,6 @@
-use serde::{Deserialize, Deserializer, Serialize};
-use sha2::{Digest, Sha256};
-use std::fmt::Display;
-use std::num::ParseIntError;
-use std::str::FromStr;
-
-use crate::PaymentId;
-
-/// Error
-#[derive(thiserror::Error, Debug)]
-pub enum Error {
-    /// The number of bytes is invalid
-    #[error("Invalid length for {0}: {1} (expected: {2})")]
-    InvalidLength(String, usize, usize),
-
-    /// The provided prefix on the string ID is unknown
-    #[error("Unknown prefix {0}")]
-    UnknownPrefix(String),
-
-    #[error("Invalid PaymentId: {0}")]
-    InvalidPaymentId(#[from] ParseIntError),
-}
-
-macro_rules! Id {
+#[macro_export]
+/// Creates a wrapper for a hexahexadecimal identifier with a human prefix
+macro_rules! BinaryId {
     ($id:ident, $suffix:expr) => {
         #[derive(Clone, Debug, Eq, PartialOrd, Ord, Hash, PartialEq)]
         /// A unique identifier for $id
@@ -155,76 +134,3 @@ macro_rules! Id {
         }
     };
 }
-
-Id!(AccountId, "account");
-Id!(TransactionId, "tx");
-
-/// A generic ID wrapper
-///
-/// This enum can be used whenever a human ID is passed and needs to be parsed and validated.
-#[derive(Debug)]
-pub enum AnyId {
-    /// AccountId
-    Account(AccountId),
-    /// TransactionId
-    Transaction(TransactionId),
-    /// Payment
-    Payment(PaymentId),
-}
-
-impl FromStr for AnyId {
-    type Err = Error;
-
-    fn from_str(value: &str) -> Result<Self, Self::Err> {
-        if value.starts_with("account") {
-            Ok(Self::Account(value.parse()?))
-        } else if value.starts_with("tx") {
-            if let Some(at) = value.find(':') {
-                let (tx, pos) = value.split_at(at);
-                Ok(Self::Payment(PaymentId {
-                    transaction: tx.parse()?,
-                    position: (pos[1..]).parse()?,
-                }))
-            } else {
-                Ok(Self::Transaction(value.parse()?))
-            }
-        } else {
-            Err(Error::UnknownPrefix(value.to_owned()))
-        }
-    }
-}
-
-impl<'de> Deserialize<'de> for AnyId {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let s = String::deserialize(deserializer)?;
-        AnyId::from_str(&s).map_err(serde::de::Error::custom)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn from_random_data() {
-        let id = "something".parse::<AccountId>().expect("hashed value");
-        let id_str = id.to_string();
-        let id_bin: &[u8] = id.as_ref();
-        assert_eq!(71, id_str.len());
-        assert_eq!(
-            <&str as TryInto<AccountId>>::try_into(id_str.as_str()).expect("valid"),
-            id
-        );
-        assert_eq!(
-            <Vec<u8> as TryInto<AccountId>>::try_into(id_bin.to_owned()).expect("valid"),
-            id
-        );
-        assert_eq!(
-            <&[u8] as TryInto<AccountId>>::try_into(id_bin).expect("valid"),
-            id
-        );
-    }
-}

utxo/src/id/error.rs

@@ -0,0 +1,15 @@
+use std::num::ParseIntError;
+
+/// Error
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+    /// The number of bytes is invalid
+    #[error("Invalid length for {0}: {1} (expected: {2})")]
+    InvalidLength(String, usize, usize),
+
+    #[error("The string is too long (max length is {0}")]
+    TooLong(usize),
+
+    #[error("Invalid PaymentId: {0}")]
+    InvalidPaymentId(#[from] ParseIntError),
+}

utxo/src/id/mod.rs

@@ -0,0 +1,113 @@
+use crate::PaymentId;
+use serde::{de, Deserialize, Deserializer, Serialize};
+use sha2::{Digest, Sha256};
+use std::{fmt::Display, ops::Deref, str::FromStr};
+
+mod binary;
+mod error;
+
+pub use error::Error;
+
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialOrd, PartialEq, Serialize)]
+/// A string with a max-length checked at compiled time
+pub struct MaxLengthString<const MAX_LENGTH: usize>(String);
+
+impl<const MAX_LENGTH: usize> PartialEq<str> for MaxLengthString<MAX_LENGTH> {
+    fn eq(&self, other: &str) -> bool {
+        self.0 == *other
+    }
+}
+
+impl<const MAX_LENGTH: usize> FromStr for MaxLengthString<MAX_LENGTH> {
+    type Err = Error;
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
+        Self::new(value.to_owned())
+    }
+}
+
+impl<const MAX_LENGTH: usize> From<&str> for MaxLengthString<MAX_LENGTH> {
+    fn from(value: &str) -> Self {
+        Self::new(value.to_owned()).expect("The string is too long")
+    }
+}
+
+impl<const MAX_LENGTH: usize> Display for MaxLengthString<MAX_LENGTH> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl<const MAX_LENGTH: usize> MaxLengthString<MAX_LENGTH> {
+    /// Creates a new instance of MaxLengthString
+    pub fn new(value: String) -> Result<Self, Error> {
+        if value.len() > MAX_LENGTH {
+            Err(Error::TooLong(MAX_LENGTH))
+        } else {
+            Ok(Self(value))
+        }
+    }
+}
+
+impl<const MAX_LENGTH: usize> Deref for MaxLengthString<MAX_LENGTH> {
+    type Target = String;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<'de, const MAX_LENGTH: usize> de::Deserialize<'de> for MaxLengthString<MAX_LENGTH> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: de::Deserializer<'de>,
+    {
+        <String as de::Deserialize>::deserialize(deserializer)
+            .and_then(|inner| Self::new(inner).map_err(|e| de::Error::custom(e.to_string())))
+    }
+}
+
+/// The AccountId data type
+pub type AccountId = MaxLengthString<64>;
+crate::BinaryId!(TransactionId, "tx");
+
+/// A generic ID wrapper
+///
+/// This enum can be used whenever a human ID is passed and needs to be parsed and validated.
+#[derive(Debug)]
+pub enum AnyId {
+    /// TransactionId
+    Transaction(TransactionId),
+    /// Payment
+    Payment(PaymentId),
+    /// Account ID
+    Account(AccountId),
+}
+
+impl FromStr for AnyId {
+    type Err = Error;
+
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
+        if value.starts_with("tx") {
+            if let Some(at) = value.find(':') {
+                let (tx, pos) = value.split_at(at);
+                return Ok(Self::Payment(PaymentId {
+                    transaction: tx.parse()?,
+                    position: (pos[1..]).parse()?,
+                }));
+            } else {
+                return Ok(Self::Transaction(value.parse()?));
+            }
+        }
+
+        Ok(Self::Account(value.parse()?))
+    }
+}
+
+impl<'de> Deserialize<'de> for AnyId {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        AnyId::from_str(&s).map_err(serde::de::Error::custom)
+    }
+}

utxo/src/ledger.rs

@@ -1,8 +1,8 @@
 use crate::{
-    storage::Storage, transaction::Type, AccountId, Amount, AssetManager, Error, Payment,
+    config::Config, storage::Storage, transaction::Type, AccountId, Amount, Error, PaymentFrom,
     PaymentId, Status, Transaction, TransactionId,
 };
-use std::{cmp::Ordering, collections::HashMap};
+use std::{cmp::Ordering, collections::HashMap, sync::Arc};
 
 /// The Verax ledger
 #[derive(Clone, Debug)]
@@ -10,8 +10,7 @@ pub struct Ledger<S>
 where
     S: Storage + Sync + Send,
 {
-    storage: S,
-    asset_manager: AssetManager,
+    config: Arc<Config<S>>,
 }
 
 impl<S> Ledger<S>
@@ -19,23 +18,12 @@ where
     S: Storage + Sync + Send,
 {
     /// Creates a new ledger instance
-    pub fn new(storage: S, asset_manager: AssetManager) -> Self {
+    pub fn new(config: Config<S>) -> Self {
         Self {
-            storage,
-            asset_manager,
+            config: Arc::new(config),
         }
     }
 
-    /// Parses a human amount (float amounts serialized as string to avoid precision loss)
-    pub fn parse_amount(&self, asset: &str, amount: &str) -> Result<Amount, Error> {
-        self.asset_manager.human_amount_by_name(asset, amount)
-    }
-
-    /// Returns a reference to the asset manager
-    pub fn asset_manager(&self) -> &AssetManager {
-        &self.asset_manager
-    }
-
     /// The internal usage is to select unspent payments for each account to
     /// create new transactions. The external API however does not expose that
     /// level of usage, instead it exposes a simple API to move funds using
@@ -55,7 +43,7 @@ where
     async fn select_payments_from_accounts(
         &self,
         payments: Vec<(AccountId, Amount)>,
-    ) -> Result<(Option<Transaction>, Vec<Payment>), Error> {
+    ) -> Result<(Option<Transaction>, Vec<PaymentFrom>), Error> {
         let mut to_spend = HashMap::new();
 
         for (account_id, amount) in payments.into_iter() {
@@ -69,12 +57,13 @@ where
 
         let mut change_input = vec![];
         let mut change_output = vec![];
-        let mut payments: Vec<Payment> = vec![];
+        let mut payments: Vec<PaymentFrom> = vec![];
 
         for ((account, asset), mut to_spend_cents) in to_spend.into_iter() {
             let iterator = self
+                .config
                 .storage
-                .get_unspent_payments(&account, asset.id, to_spend_cents)
+                .get_unspent_payments(&account, &asset, to_spend_cents)
                 .await?;
             for payment in iterator.into_iter() {
                 let cents = payment.amount.cents();
@@ -97,7 +86,7 @@ where
                         let to_spend_cents = to_spend_cents.abs();
                         let input = payments
                             .pop()
-                            .ok_or(Error::InsufficientBalance(account.clone(), asset.id))?;
+                            .ok_or(Error::InsufficientBalance(account.clone(), asset.clone()))?;
 
                         change_input.push(input);
                         change_output
@@ -117,30 +106,38 @@ where
             if to_spend_cents > 0 {
                 // We don't have enough payment to cover the to_spend_cents
                 // Return an insufficient balance error
-                return Err(Error::InsufficientBalance(account, asset.id));
+                return Err(Error::InsufficientBalance(account, asset.clone()));
             }
         }
 
         let exchange_tx = if change_input.is_empty() {
             None
         } else {
-            let total = change_input.len();
+            let total = change_input.len() as u16;
             let split_input = Transaction::new(
                 "Exchange transaction".to_owned(),
                 // Set the change transaction as settled. This is an
                 // internal transaction to split existing payments
                 // into exact new payments, so the main transaction has no
                 // change.
-                Status::Settled,
+                self.config.status.default_spendable(),
                 Type::Exchange,
                 change_input,
                 change_output,
             )
             .await?;
 
+            let creates = split_input.creates();
             for i in 0..total {
                 // Spend the new payment
-                payments.push(split_input.creates()[i * 2].clone());
+                payments.push(PaymentFrom {
+                    id: PaymentId {
+                        transaction: split_input.id.clone(),
+                        position: i * 2,
+                    },
+                    from: creates[(i * 2) as usize].to.clone(),
+                    amount: creates[(i * 2) as usize].amount.clone(),
+                });
             }
             Some(split_input)
         };
@@ -177,11 +174,11 @@ where
     ) -> Result<Transaction, Error> {
         let (change_transaction, payments) = self.select_payments_from_accounts(from).await?;
         if let Some(mut change_tx) = change_transaction {
-            change_tx.persist(&self.storage).await?;
+            change_tx.persist(&self.config).await?;
         }
         let mut transaction =
             Transaction::new(reference, status, Type::Transaction, payments, to).await?;
-        transaction.persist(&self.storage).await?;
+        transaction.persist(&self.config).await?;
         Ok(transaction)
     }
 
@@ -193,7 +190,7 @@ where
     ///
     /// TODO: Return locked funds as well.
     pub async fn get_balance(&self, account: &AccountId) -> Result<Vec<Amount>, Error> {
-        Ok(self.storage.get_balance(account).await?)
+        Ok(self.config.storage.get_balance(account).await?)
     }
 
     /// Creates an external deposit
@@ -210,7 +207,7 @@ where
     ) -> Result<Transaction, Error> {
         let mut transaction =
             Transaction::new_external_deposit(reference, status, vec![(account.clone(), amount)])?;
-        transaction.persist(&self.storage).await?;
+        transaction.persist(&self.config).await?;
         Ok(transaction)
     }
 
@@ -231,16 +228,16 @@ where
             .select_payments_from_accounts(vec![(account.clone(), amount)])
             .await?;
         for mut change_tx in change_transactions.into_iter() {
-            change_tx.persist(&self.storage).await?;
+            change_tx.persist(&self.config).await?;
         }
         let mut transaction = Transaction::new_external_withdrawal(reference, status, payments)?;
-        transaction.persist(&self.storage).await?;
+        transaction.persist(&self.config).await?;
         Ok(transaction)
     }
 
     /// Returns the payment object by a given payment id
-    pub async fn get_payment_info(&self, payment_id: &PaymentId) -> Result<Payment, Error> {
-        Ok(self.storage.get_payment(payment_id).await?)
+    pub async fn get_payment_info(&self, _payment_id: &PaymentId) -> Result<PaymentFrom, Error> {
+        todo!()
     }
 
     /// Returns the transaction object by a given transaction id
@@ -248,11 +245,7 @@ where
         &self,
         transaction_id: &TransactionId,
     ) -> Result<Transaction, Error> {
-        Ok(self
-            .storage
-            .get_transaction(transaction_id)
-            .await?
-            .try_into()?)
+        Ok(self.config.storage.get_transaction(transaction_id).await?)
     }
 
     /// Returns all transactions from a given account. It can be optionally be
@@ -268,15 +261,11 @@ where
         } else {
             types
         };
-        let r = self
+        Ok(self
+            .config
             .storage
             .get_transactions(account_id, &types, &[])
-            .await?
-            .into_iter()
-            .map(|x| x.try_into())
-            .collect::<Result<Vec<Transaction>, _>>()?;
-
-        Ok(r)
+            .await?)
     }
 
     /// Attempts to change the status of a given transaction id. On success the
@@ -287,13 +276,12 @@ where
         new_status: Status,
         reason: String,
     ) -> Result<Transaction, Error> {
-        let mut tx: Transaction = self
+        Ok(self
+            .config
             .storage
             .get_transaction(transaction_id)
             .await?
-            .try_into()?;
-        tx.change_status(new_status, reason)?;
-        tx.persist(&self.storage).await?;
-        Ok(tx)
+            .change_status(&self.config, new_status, reason)
+            .await?)
     }
 }

utxo/src/lib.rs

@@ -19,11 +19,13 @@
 
 #![deny(missing_docs)]
 #![deny(warnings)]
+#![deny(unused_crate_dependencies)]
+#![deny(clippy::arithmetic_side_effects)]
+#![deny(clippy::cast_possible_truncation)]
 
 mod amount;
 mod asset;
-mod asset_manager;
-mod changelog;
+mod config;
 mod error;
 mod id;
 mod ledger;
@@ -38,13 +40,12 @@ mod transaction;
 #[cfg(test)]
 pub use self::storage::test as storage_test;
 pub use self::{
-    amount::Amount,
+    amount::{Amount, AnyAmount, HumanAmount},
     asset::Asset,
-    asset_manager::{AssetDefinition, AssetManager},
     error::Error,
     id::*,
     ledger::Ledger,
-    payment::{Payment, PaymentId},
+    payment::{PaymentFrom, PaymentId},
     serde::*,
     status::Status,
     transaction::{Transaction, Type},

utxo/src/payment.rs

@@ -1,6 +1,6 @@
-use crate::{changelog::Changelog, AccountId, Amount, Status, TransactionId};
-use serde::{Deserialize, Serialize, Serializer};
-use std::ops::Deref;
+use crate::{id::Error, AccountId, Amount, TransactionId};
+use serde::{de, Deserialize, Serialize, Serializer};
+use std::{fmt, ops::Deref, str::FromStr};
 
 #[derive(Clone, Debug, Eq, Ord, Hash, PartialOrd, PartialEq)]
 /// PaymentID
@@ -12,15 +12,38 @@ pub struct PaymentId {
     /// Transaction which created this payment
     pub transaction: TransactionId,
     /// This payment position inside the transaction
-    pub position: usize,
+    pub position: u16,
+}
+
+impl FromStr for PaymentId {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let parts: Vec<&str> = s.split(':').collect();
+        if parts.len() != 2 {
+            return Err(Error::InvalidLength(
+                "payment_id".to_owned(),
+                2,
+                parts.len(),
+            ));
+        }
+
+        let transaction = parts[0].try_into()?;
+        let position = parts[1].parse()?;
+
+        Ok(PaymentId {
+            transaction,
+            position,
+        })
+    }
 }
 
 impl PaymentId {
     /// Returns the bytes representation of the PaymentId
-    pub fn bytes(&self) -> [u8; 40] {
-        let mut bytes = [0u8; 40];
+    pub fn bytes(&self) -> [u8; 34] {
+        let mut bytes = [0u8; 34];
         bytes[0..32].copy_from_slice(self.transaction.deref());
-        bytes[32..40].copy_from_slice(&self.position.to_be_bytes());
+        bytes[32..34].copy_from_slice(&self.position.to_be_bytes());
         bytes
     }
 }
@@ -41,71 +64,49 @@ impl ToString for PaymentId {
     }
 }
 
-#[derive(Debug, Deserialize, PartialEq, Eq, Serialize, Clone)]
-pub struct ChangelogEntry {
-    pub reason: String,
-    pub status: Status,
-    pub spent: Option<SpentInfo>,
+struct PaymentIdVisitor;
+
+impl<'de> de::Visitor<'de> for PaymentIdVisitor {
+    type Value = PaymentId;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str("a string in the format 'transaction_id:position'")
+    }
+
+    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        value
+            .parse()
+            .map_err(|e: Error| E::custom(format!("Invalid payment ID: {}", e.to_string())))
+    }
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
-pub struct SpentInfo {
-    pub by: TransactionId,
-    pub status: Status,
+impl<'de> de::Deserialize<'de> for PaymentId {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: de::Deserializer<'de>,
+    {
+        deserializer.deserialize_str(PaymentIdVisitor)
+    }
 }
 
-/// Payment
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct Payment {
-    /// The payment ID
-    pub id: PaymentId,
+#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
+pub struct PaymentTo {
     /// Which account can spend this new payment
     pub to: AccountId,
     /// The amount of the payment
     pub amount: Amount,
-    /// The status of the payment. This status is just the status of identical
-    /// to the status of the transaction which created this payment.
-    pub status: Status,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    /// What is the spending status of the payment. If the payment is not spent it will be None
-    pub spent: Option<SpentInfo>,
-    /// The changelog of this payment
-    pub changelog: Vec<Changelog<ChangelogEntry>>,
 }
 
-impl Payment {
-    /// Returns true if the payment is spendable
-    #[inline]
-    pub fn is_spendable(&self) -> bool {
-        self.spent.is_none() && self.status == Status::Settled
-    }
-
-    /// Returns true if the payment is spendable or was spent by a given transaction
-    pub fn is_spendable_or_was_by(&self, by: &TransactionId) -> bool {
-        if let Some(spent) = self.spent.as_ref() {
-            if &spent.by != by {
-                return false;
-            }
-        }
-        self.status == Status::Settled
-    }
-
-    /// Appends a new changelog taking a snapshot of the current object
-    pub fn new_changelog(&mut self, reference: &str) {
-        let previous_id = if let Some(Ok(previous_id)) = self.changelog.last().map(|x| x.id()) {
-            Some(previous_id)
-        } else {
-            None
-        };
-
-        self.changelog.push(Changelog::new(
-            previous_id,
-            self.id.bytes().to_vec(),
-            ChangelogEntry {
-                status: self.status.clone(),
-                reason: reference.to_owned(),
-                spent: self.spent.clone(),
-            },
-        ));
-    }
+/// Payment
+#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
+pub struct PaymentFrom {
+    /// The payment ID
+    pub id: PaymentId,
+    /// Which account is paying
+    pub from: AccountId,
+    /// The amount of the payment
+    pub amount: Amount,
 }

utxo/src/status.rs

@@ -1,172 +1,103 @@
+use crate::MaxLengthString;
 use serde::{Deserialize, Serialize};
-use strum_macros::{Display, EnumIter};
+use std::collections::HashMap;
 
-/// Transaction status
-#[derive(Clone, Eq, PartialEq, Debug, Display, Serialize, EnumIter, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum Status {
-    /// Pending status
-    ///
-    /// A transaction has been created. At this status the transaction can be
-    /// Cancelled.
-    /// From Processing it can be moved to Settled or Failed.
-    Pending,
-    /// Processing
-    ///
-    /// The transaction leaves the Pending status and it cannot longer be
-    /// Cancelled by an external event.
-    Processing,
-    /// Cancelled.
-    ///
-    /// The transaction has been Cancelled, the funds that were burned are
-    /// released and can be used again.
-    Cancelled,
-    /// Settled
-    ///
-    /// The transaction is settled, the inputs used to create the transaction
-    /// are forever burned.
-    Settled,
-    /// Failed
-    ///
-    /// The transaction has failed, the inputs used to create the transaction
-    /// are released and can be used again.
-    Failed,
-}
+/// Status type
+pub type Status = MaxLengthString<10>;
 
-impl Default for Status {
-    fn default() -> Self {
-        Self::Pending
-    }
+#[derive(Debug, Serialize, Deserialize)]
+pub struct StatusManager {
+    statuses: Vec<Status>,
+    spendable: Vec<Status>,
+    default_spendable: Status,
+    reverted: Vec<Status>,
+    withdrawable: Vec<Status>,
+    transition: HashMap<Status, Vec<Status>>,
 }
 
-#[derive(thiserror::Error, Debug)]
+/// Status error object
+#[derive(Debug, Serialize, thiserror::Error)]
 pub enum Error {
-    #[error("Invalid status: {0}")]
-    InvalidStatus(u32),
-}
+    #[error("Unknown status: {0}")]
+    UnknownStatus(String),
 
-impl TryFrom<u32> for Status {
-    type Error = Error;
-    fn try_from(value: u32) -> Result<Self, Self::Error> {
-        match value {
-            0 => Ok(Self::Pending),
-            10 => Ok(Self::Processing),
-            20 => Ok(Self::Cancelled),
-            30 => Ok(Self::Settled),
-            40 => Ok(Self::Failed),
-            _ => Err(Error::InvalidStatus(value)),
-        }
-    }
+    #[error("Invalid transition from {0} to {1}")]
+    InvalidTransition(Status, Status),
 }
 
-impl From<Status> for u32 {
-    fn from(value: Status) -> Self {
-        (&value).into()
+impl StatusManager {
+    pub fn new_status(&self, status_name: &str) -> Result<Status, Error> {
+        self.statuses
+            .iter()
+            .find(|status| *status == status_name)
+            .cloned()
+            .ok_or(Error::UnknownStatus(status_name.to_owned()))
     }
-}
 
-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,
-        }
+    pub fn spendables(&self) -> &[Status] {
+        &self.spendable
     }
-}
 
-impl Status {
-    /// Checks if the current status can transition to the new state.
-    pub fn can_transition_to(&self, new_status: &Status) -> bool {
-        if self == new_status {
-            false
-        } else {
-            match self {
-                Self::Pending => true,
-                Self::Processing => {
-                    matches!(new_status, Self::Settled | Self::Failed)
-                }
-                _ => false,
-            }
-        }
+    pub fn default_spendable(&self) -> Status {
+        self.default_spendable.clone()
     }
 
-    /// Checks if the current status is a rollback operation.
-    ///
-    /// In a rollback operation any previously spent payments are released by the storage layer.
-    pub fn is_rollback(&self) -> bool {
-        matches!(self, Self::Cancelled | Self::Failed)
+    /// Spendable statuses are the final state of a transaction that has finished as successfully
+    /// therefore it is spendable.
+    pub fn is_spendable(&self, status: &Status) -> bool {
+        self.spendable.contains(status)
     }
 
-    /// Checks if the transaction status is finalized
-    pub fn is_finalized(&self) -> bool {
-        matches!(self, Self::Cancelled | Self::Settled | Self::Failed)
+    /// Reverted transactions are the final state of a transaction that has failed or cancelled and
+    /// they inputs payments are reverted and spendedable.
+    pub fn is_reverted(&self, status: &Status) -> bool {
+        self.reverted.contains(status)
     }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
 
-    #[test]
-    fn pending() {
-        let status = Status::Pending;
-        assert!(!status.can_transition_to(&Status::Pending));
-        assert!(status.can_transition_to(&Status::Processing));
-        assert!(status.can_transition_to(&Status::Cancelled));
-        assert!(status.can_transition_to(&Status::Settled));
-        assert!(status.can_transition_to(&Status::Failed));
-        assert!(!status.is_finalized());
-        assert!(!status.is_rollback());
+    /// The transaction is final and cannot longer be updated
+    pub fn is_final(&self, status: &Status) -> bool {
+        self.is_spendable(status) || self.is_reverted(status)
     }
 
-    #[test]
-    fn processing() {
-        let status = Status::Processing;
-        assert!(!status.can_transition_to(&Status::Pending));
-        assert!(!status.can_transition_to(&Status::Processing));
-        assert!(!status.can_transition_to(&Status::Cancelled));
-        assert!(status.can_transition_to(&Status::Settled));
-        assert!(status.can_transition_to(&Status::Failed));
-        assert!(!status.is_finalized());
-        assert!(!status.is_rollback());
-    }
-
-    #[test]
-    fn cancelled() {
-        let status = Status::Cancelled;
-        assert!(!status.can_transition_to(&Status::Pending));
-        assert!(!status.can_transition_to(&Status::Processing));
-        assert!(!status.can_transition_to(&Status::Cancelled));
-        assert!(!status.can_transition_to(&Status::Settled));
-        assert!(!status.can_transition_to(&Status::Failed));
-        assert!(status.is_finalized());
-        assert!(status.is_rollback());
+    /// Checks if the status transition is allowed
+    pub fn is_valid_transition(&self, from: &Status, to: &Status) -> Result<(), Error> {
+        if self.transition.get(from).map_or(false, |v| v.contains(to)) {
+            Ok(())
+        } else {
+            Err(Error::InvalidTransition(from.clone(), to.clone()))
+        }
     }
+}
 
-    #[test]
-    fn settled() {
-        let status = Status::Settled;
-        assert!(!status.can_transition_to(&Status::Pending));
-        assert!(!status.can_transition_to(&Status::Processing));
-        assert!(!status.can_transition_to(&Status::Cancelled));
-        assert!(!status.can_transition_to(&Status::Settled));
-        assert!(!status.can_transition_to(&Status::Failed));
-        assert!(status.is_finalized());
-        assert!(!status.is_rollback());
-    }
+impl Default for StatusManager {
+    fn default() -> Self {
+        let pending: Status = "pending".into();
+        let processing: Status = "processing".into();
+        let cancelled: Status = "cancelled".into();
+        let settled: Status = "settled".into();
+        let failed: Status = "failed".into();
 
-    #[test]
-    fn failed() {
-        let status = Status::Failed;
-        assert!(!status.can_transition_to(&Status::Pending));
-        assert!(!status.can_transition_to(&Status::Processing));
-        assert!(!status.can_transition_to(&Status::Cancelled));
-        assert!(!status.can_transition_to(&Status::Settled));
-        assert!(!status.can_transition_to(&Status::Failed));
-        assert!(status.is_finalized());
-        assert!(status.is_rollback());
+        Self {
+            statuses: vec![
+                pending.clone(),
+                processing.clone(),
+                cancelled.clone(),
+                settled.clone(),
+                failed.clone(),
+            ],
+            default_spendable: settled.clone(),
+            spendable: vec![settled.clone()],
+            reverted: vec![cancelled.clone(), failed.clone()],
+            withdrawable: vec![settled.clone()],
+            transition: {
+                let mut map = HashMap::new();
+                map.insert(
+                    pending.clone(),
+                    vec![processing.clone(), settled.clone(), cancelled.clone()],
+                );
+                map.insert(processing.clone(), vec![settled, failed]);
+                map
+            },
+        }
     }
 }

utxo/src/storage/cache/batch.rs

@@ -1,11 +1,9 @@
 use super::CacheStorage;
 use crate::{
-    changelog::Changelog,
-    storage::{Batch, Error},
-    transaction::from_db,
-    AccountId, Amount, Payment, PaymentId, Status, Transaction, TransactionId,
+    payment::PaymentTo,
+    storage::{Batch, Error, Status},
+    AccountId, Amount, PaymentFrom, PaymentId, Transaction, TransactionId,
 };
-use serde::{de::DeserializeOwned, Serialize};
 use std::{collections::HashMap, marker::PhantomData};
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -20,9 +18,9 @@ where
     B: Batch<'a> + Send,
 {
     inner: B,
-    payments: CacheStorage<PaymentId, Payment>,
+    payments: CacheStorage<PaymentId, PaymentFrom>,
     balances: CacheStorage<AccountId, Vec<Amount>>,
-    transactions: CacheStorage<TransactionId, from_db::Transaction>,
+    transactions: CacheStorage<TransactionId, Transaction>,
     to_invalidate: HashMap<Ids, ()>,
     _phantom: PhantomData<&'a ()>,
 }
@@ -33,9 +31,9 @@ where
 {
     pub fn new(
         batch: B,
-        payments: CacheStorage<PaymentId, Payment>,
+        payments: CacheStorage<PaymentId, PaymentFrom>,
         balances: CacheStorage<AccountId, Vec<Amount>>,
-        transactions: CacheStorage<TransactionId, from_db::Transaction>,
+        transactions: CacheStorage<TransactionId, Transaction>,
     ) -> Self {
         Self {
             inner: batch,
@@ -77,29 +75,41 @@ where
         Ok(())
     }
 
-    async fn rollback(self) -> Result<(), Error> {
-        self.inner.rollback().await
+    async fn get_transaction(
+        &mut self,
+        transaction_id: &TransactionId,
+    ) -> Result<Transaction, Error> {
+        self.inner.get_transaction(transaction_id).await
     }
 
-    async fn store_changelogs<T: DeserializeOwned + Serialize + Send + Sync>(
+    async fn relate_account_to_transaction(
         &mut self,
-        changelog: &[Changelog<T>],
+        transaction_id: &TransactionId,
+        account: &AccountId,
+        typ: crate::Type,
     ) -> Result<(), Error> {
-        self.inner.store_changelogs(changelog).await
+        self.to_invalidate
+            .insert(Ids::Transaction(transaction_id.clone()), ());
+        self.to_invalidate.insert(Ids::Account(account.clone()), ());
+        self.inner
+            .relate_account_to_transaction(transaction_id, account, typ)
+            .await
     }
 
-    async fn update_payment(
+    async fn rollback(self) -> Result<(), Error> {
+        self.inner.rollback().await
+    }
+
+    async fn update_transaction_payments(
         &mut self,
-        payment_id: &PaymentId,
-        spent_by: &TransactionId,
-        spent_status: Status,
-    ) -> Result<(), Error> {
-        self.to_invalidate
-            .insert(Ids::Payment(payment_id.clone()), ());
+        transaction_id: &TransactionId,
+        create_status: Status,
+        spend_status: Status,
+    ) -> Result<(usize, usize), Error> {
         self.to_invalidate
-            .insert(Ids::Transaction(spent_by.clone()), ());
+            .insert(Ids::Transaction(transaction_id.clone()), ());
         self.inner
-            .update_payment(payment_id, spent_by, spent_status)
+            .update_transaction_payments(transaction_id, create_status, spend_status)
             .await
     }
 
@@ -112,10 +122,33 @@ where
         self.inner.get_payment_status(transaction_id).await
     }
 
-    async fn store_new_payment(&mut self, payment: &Payment) -> Result<(), Error> {
-        self.to_invalidate
-            .insert(Ids::Payment(payment.id.clone()), ());
-        self.inner.store_new_payment(payment).await
+    async fn spend_payments(
+        &mut self,
+        transaction_id: &TransactionId,
+        spends: Vec<PaymentId>,
+        status: Status,
+    ) -> Result<(), Error> {
+        for spend in &spends {
+            self.to_invalidate.insert(Ids::Payment(spend.clone()), ());
+        }
+        self.inner
+            .spend_payments(transaction_id, spends, status)
+            .await
+    }
+
+    async fn create_payments(
+        &mut self,
+        transaction_id: &TransactionId,
+        recipients: &[PaymentTo],
+        status: Status,
+    ) -> Result<(), Error> {
+        for recipient in recipients {
+            self.to_invalidate
+                .insert(Ids::Account(recipient.to.clone()), ());
+        }
+        self.inner
+            .create_payments(transaction_id, recipients, status)
+            .await
     }
 
     async fn store_transaction(&mut self, transaction: &Transaction) -> Result<(), Error> {
@@ -133,17 +166,4 @@ where
             .insert(Ids::Transaction(transaction.id().clone()), ());
         self.inner.tag_transaction(transaction, tags).await
     }
-
-    async fn relate_account_to_transaction(
-        &mut self,
-        transaction: &Transaction,
-        account: &AccountId,
-    ) -> Result<(), Error> {
-        self.to_invalidate
-            .insert(Ids::Transaction(transaction.id().clone()), ());
-        self.to_invalidate.insert(Ids::Account(account.clone()), ());
-        self.inner
-            .relate_account_to_transaction(transaction, account)
-            .await
-    }
 }

utxo/src/storage/cache/mod.rs

@@ -1,13 +1,10 @@
 //! Cache storage implementation.
 use crate::{
     amount::AmountCents,
-    asset::AssetId,
-    changelog::Changelog,
     storage::{Error, Storage},
-    transaction::from_db::Transaction,
-    AccountId, Amount, Payment, PaymentId, TransactionId, Type,
+    transaction::Transaction,
+    AccountId, Amount, Asset, PaymentFrom, PaymentId, TransactionId, Type,
 };
-use serde::{de::DeserializeOwned, Serialize};
 use std::{collections::HashMap, sync::Arc};
 use tokio::sync::RwLock;
 
@@ -24,7 +21,7 @@ pub struct Cache<S>
 where
     S: Storage + Sync + Send,
 {
-    payments: CacheStorage<PaymentId, Payment>,
+    payments: CacheStorage<PaymentId, PaymentFrom>,
     balances: CacheStorage<AccountId, Vec<Amount>>,
     transactions: CacheStorage<TransactionId, Transaction>,
     inner: S,
@@ -63,21 +60,6 @@ where
         ))
     }
 
-    async fn get_payment(&self, id: &PaymentId) -> Result<Payment, Error> {
-        let payments = self.payments.read().await;
-        if let Some(payment) = payments.get(id).cloned() {
-            Ok(payment)
-        } else {
-            drop(payments);
-            let result = self.inner.get_payment(id).await?;
-            self.payments
-                .write()
-                .await
-                .insert(id.clone(), result.clone());
-            Ok(result)
-        }
-    }
-
     async fn get_balance(&self, account_id: &AccountId) -> Result<Vec<Amount>, Error> {
         let cache = self.balances.read().await;
         if let Some(balances) = cache.get(account_id).cloned() {
@@ -108,19 +90,12 @@ where
         }
     }
 
-    async fn get_changelogs<T: DeserializeOwned + Serialize + Send + Sync>(
-        &self,
-        object_id: Vec<u8>,
-    ) -> Result<Vec<Changelog<T>>, Error> {
-        self.inner.get_changelogs(object_id).await
-    }
-
     async fn get_unspent_payments(
         &self,
         account: &AccountId,
-        asset: AssetId,
+        asset: &Asset,
         target_amount: AmountCents,
-    ) -> Result<Vec<Payment>, Error> {
+    ) -> Result<Vec<PaymentFrom>, Error> {
         self.inner
             .get_unspent_payments(account, asset, target_amount)
             .await
@@ -139,14 +114,11 @@ where
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::{
-        storage::sqlite::SQLite, storage_test_suite, tests::deposit, AssetDefinition, AssetManager,
-        Ledger, Status,
-    };
+    use crate::{storage::sqlite::SQLite, storage_test_suite, tests::deposit, Ledger};
     use sqlx::sqlite::{SqliteConnectOptions, SqlitePoolOptions};
     use std::fs::remove_file;
 
-    async fn get_instance(assets: AssetManager, test: &str) -> Cache<SQLite> {
+    async fn get_instance(test: &str) -> Cache<SQLite> {
         let path = format!("/tmp/cache-{}.db", test);
         let _ = remove_file(&path);
         let settings = path
@@ -159,14 +131,14 @@ mod test {
             .await
             .expect("pool");
 
-        let db = SQLite::new(pool, assets);
+        let db = SQLite::new(pool);
         db.setup().await.expect("setup");
         Cache::new(db)
     }
 
     storage_test_suite!();
 
-    pub async fn get_ledger_and_asset_manager() -> (AssetManager, Ledger<Cache<SQLite>>) {
+    pub async fn get_ledger_and_asset_manager() -> Ledger<Cache<SQLite>> {
         let pool = SqlitePoolOptions::new()
             .max_connections(1)
             .idle_timeout(None)
@@ -175,14 +147,9 @@ mod test {
             .await
             .expect("pool");
 
-        let assets = AssetManager::new(vec![
-            AssetDefinition::new(1, "BTC", 8),
-            AssetDefinition::new(2, "USD", 4),
-        ]);
-
-        let db = SQLite::new(pool, assets.clone());
+        let db = SQLite::new(pool);
         db.setup().await.expect("setup");
-        (assets.clone(), Ledger::new(Cache::new(db), assets))
+        Ledger::new(Cache::new(db).into())
     }
 
     #[tokio::test]
@@ -190,58 +157,40 @@ mod test {
         let source = "account1".parse::<AccountId>().expect("account");
         let dest = "account2".parse::<AccountId>().expect("account");
         let fee = "fee".parse::<AccountId>().expect("account");
-        let (assets, ledger) = get_ledger_and_asset_manager().await;
-
-        deposit(
-            &ledger,
-            &source,
-            assets.amount_by_and_cents(2, 1000).expect("amount"),
-        )
-        .await;
-        deposit(
-            &ledger,
-            &source,
-            assets.amount_by_and_cents(2, 2000).expect("amount"),
-        )
-        .await;
+        let ledger = get_ledger_and_asset_manager().await;
+        let usd: Asset = "USD/2".parse().expect("asset");
+
+        deposit(&ledger, &source, usd.from_human("10").expect("amount")).await;
+        deposit(&ledger, &source, usd.from_human("20").expect("amount")).await;
 
         assert_eq!(
-            vec![assets.amount_by_and_cents(2, 3000).expect("amount")],
+            vec![usd.from_human("30").expect("amount"),],
             ledger.get_balance(&source).await.expect("balance")
         );
 
         ledger
             .new_transaction(
                 "Exchange one".to_owned(),
-                Status::Settled,
-                vec![(
-                    source.clone(),
-                    assets.amount_by_and_cents(2, 1300).expect("amount"),
-                )],
+                "settled".into(),
+                vec![(source.clone(), usd.from_human("13").expect("amount"))],
                 vec![
-                    (
-                        dest.clone(),
-                        assets.amount_by_and_cents(2, 1250).expect("amount"),
-                    ),
-                    (
-                        fee.clone(),
-                        assets.amount_by_and_cents(2, 50).expect("amount"),
-                    ),
+                    (dest.clone(), usd.from_human("12.5").expect("amount")),
+                    (fee.clone(), usd.from_human("0.5").expect("amount")),
                 ],
             )
             .await
             .expect("valid tx");
 
         assert_eq!(
-            vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
+            vec![usd.from_human("17").expect("amount"),],
             ledger.get_balance(&source).await.expect("balance")
         );
         assert_eq!(
-            vec![assets.amount_by_and_cents(2, 1250).expect("amount")],
+            vec![usd.from_human("12.5").expect("amount"),],
             ledger.get_balance(&dest).await.expect("balance")
         );
         assert_eq!(
-            vec![assets.amount_by_and_cents(2, 50).expect("amount")],
+            vec![usd.from_human("0.5").expect("amount"),],
             ledger.get_balance(&fee).await.expect("balance")
         );
     }

utxo/src/storage/mod.rs

@@ -1,12 +1,9 @@
 //! Storage layer trait
 use crate::{
-    amount::AmountCents,
-    asset::AssetId,
-    changelog::{self, Changelog},
-    transaction::{from_db, Type},
-    AccountId, Amount, Payment, PaymentId, Status, Transaction, TransactionId,
+    amount::AmountCents, payment::PaymentTo, transaction::Type, AccountId, Amount, Asset,
+    PaymentFrom, PaymentId, Transaction, TransactionId,
 };
-use serde::{de::DeserializeOwned, Serialize};
+use serde::Serialize;
 
 pub mod cache;
 #[cfg(any(feature = "sqlite", test))]
@@ -15,6 +12,44 @@ pub use self::cache::Cache;
 #[cfg(any(feature = "sqlite", test))]
 pub use self::sqlite::SQLite;
 
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Serialize)]
+/// Storage Payment Status
+pub enum Status {
+    ///  The payment is available to be spent
+    Spendable,
+    /// The payment is not spentable and will not be part of the balance
+    Failed,
+    /// The payment is unspendable temporarily, it can be updated to any other status
+    Locked,
+    /// The transaction has been spent
+    Spent,
+}
+
+impl From<Status> for u32 {
+    fn from(val: Status) -> Self {
+        match val {
+            Status::Spendable => 0,
+            Status::Locked => 20,
+            Status::Spent => 30,
+            Status::Failed => 40,
+        }
+    }
+}
+
+impl TryFrom<u32> for Status {
+    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),
+            _ => Err(Error::Storage(format!("Invalid status: {}", value))),
+        }
+    }
+}
+
 #[derive(thiserror::Error, Debug, Serialize)]
 /// Storage error
 pub enum Error {
@@ -38,9 +73,9 @@ pub enum Error {
     /// The requested record was not found
     NotFound,
 
-    #[error("Error while parsing changelog: {0}")]
-    /// Error while parsing changelog
-    Changelog(#[from] changelog::Error),
+    #[error("Internal error with encoding: {0}")]
+    /// Error with the encoding/decoding
+    Encoding(String),
 
     #[error("Not enough unspent payments (missing {0} cents)")]
     /// TODO: Convert the AmountCents to Amount for better error reporting upstream
@@ -59,29 +94,42 @@ pub trait Batch<'a> {
     /// The batch is commited into the storage layer and it is consumed.
     async fn commit(self) -> Result<(), Error>;
 
-    /// Stores a changelogs event
-    async fn store_changelogs<T: DeserializeOwned + Serialize + Send + Sync>(
+    /// Gets the last transaction from the Batch, potentially the database implementation should
+    /// lock the transaction record for update to avoid concurrency issues
+    async fn get_transaction(
+        &mut self,
+        transaction_id: &TransactionId,
+    ) -> Result<Transaction, Error>;
+
+    /// Flag the given payments as spent by the given transaction.
+    async fn spend_payments(
+        &mut self,
+        transaction_id: &TransactionId,
+        spends: Vec<PaymentId>,
+        status: Status,
+    ) -> Result<(), Error>;
+
+    /// Create a new list of payments
+    async fn create_payments(
         &mut self,
-        changelog: &[Changelog<T>],
+        transaction_id: &TransactionId,
+        recipients: &[PaymentTo],
+        status: Status,
     ) -> Result<(), Error>;
 
-    /// Spends a payment.
+    /// Updates all payments related to a transaction
     ///
-    /// Under normal circumstances the transaction_id is required, and the
-    /// payment is marked as spent.
+    /// This function will update the created and spent payments related to a given transaction.
     ///
-    /// If the transaction_id is None, the payment is released and can be spent
-    /// again. This will only happen when the transaction that spent this
-    /// payment was either cancelled or failed. The original transaction will
-    /// exists forever either as failed or cancelled and will reference the
-    /// original payment, but the underlying payment that was just released will
-    /// become spendable again
-    async fn update_payment(
+    /// This function must check the previous status before changing it. For instance, Failed and
+    /// Spent are final statuses, making the transaction read-only, going forward. The status
+    /// from NotSpentable to Spendable can only be done by the parent transaction, and not other.
+    async fn update_transaction_payments(
         &mut self,
-        payment_id: &PaymentId,
-        spent_by: &TransactionId,
-        spent_status: Status,
-    ) -> Result<(), Error>;
+        transaction_id: &TransactionId,
+        create_status: Status,
+        spend_status: Status,
+    ) -> 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(
@@ -89,9 +137,6 @@ pub trait Batch<'a> {
         transaction_id: &TransactionId,
     ) -> Result<Option<Status>, Error>;
 
-    /// Stores a payment (that was created by a transaction)
-    async fn store_new_payment(&mut self, payment: &Payment) -> Result<(), Error>;
-
     /// Stores a transaction
     async fn store_transaction(&mut self, transaction: &Transaction) -> Result<(), Error>;
 
@@ -111,8 +156,9 @@ pub trait Batch<'a> {
     /// layer.
     async fn relate_account_to_transaction(
         &mut self,
-        transaction: &Transaction,
+        transaction: &TransactionId,
         account: &AccountId,
+        typ: Type,
     ) -> Result<(), Error>;
 }
 
@@ -138,19 +184,6 @@ pub trait Storage {
     /// The batch has also a rollback
     async fn begin<'a>(&'a self) -> Result<Self::Batch<'a>, Error>;
 
-    /// Returns a payment object by ID.
-    async fn get_payment(&self, id: &PaymentId) -> Result<Payment, Error>;
-
-    /// Similar to get_payment() but errors if the requested payment is not spendable.
-    async fn get_unspent_payment(&self, id: &PaymentId) -> Result<Payment, Error> {
-        let payment = self.get_payment(id).await?;
-        if payment.is_spendable() {
-            Ok(payment)
-        } else {
-            Err(Error::NotFound)
-        }
-    }
-
     /// Returns the balances for a given account
     async fn get_balance(&self, account: &AccountId) -> Result<Vec<Amount>, Error>;
 
@@ -164,15 +197,12 @@ pub trait Storage {
     async fn get_unspent_payments(
         &self,
         account: &AccountId,
-        asset: AssetId,
+        asset: &Asset,
         target_amount: AmountCents,
-    ) -> Result<Vec<Payment>, Error>;
+    ) -> Result<Vec<PaymentFrom>, Error>;
 
     /// Returns a transaction object by id
-    async fn get_transaction(
-        &self,
-        transaction_id: &TransactionId,
-    ) -> Result<from_db::Transaction, Error>;
+    async fn get_transaction(&self, transaction_id: &TransactionId) -> Result<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
@@ -182,33 +212,21 @@ pub trait Storage {
         account: &AccountId,
         types: &[Type],
         tags: &[String],
-    ) -> Result<Vec<from_db::Transaction>, Error>;
-
-    /// Returns all changelogs associated with a given object_id. The result should be sorted from oldest to newest.
-    async fn get_changelogs<T: DeserializeOwned + Serialize + Send + Sync>(
-        &self,
-        object_id: Vec<u8>,
-    ) -> Result<Vec<Changelog<T>>, Error>;
+    ) -> Result<Vec<Transaction>, Error>;
 }
 
 #[cfg(test)]
 pub mod test {
     use super::*;
-    use crate::{payment::SpentInfo, AssetManager};
     use rand::Rng;
-    use strum::IntoEnumIterator;
 
     #[macro_export]
     macro_rules! storage_unit_test {
         ($name:ident) => {
             #[tokio::test]
             async fn $name() {
-                let assets = AssetManager::new(vec![
-                    AssetDefinition::new(1, "BTC", 8),
-                    AssetDefinition::new(2, "USD", 4),
-                ]);
-                let ledger = get_instance(assets.clone(), stringify!($name)).await;
-                $crate::storage::test::$name(&ledger, assets).await;
+                let ledger = get_instance(stringify!($name)).await;
+                $crate::storage::test::$name(&ledger).await;
             }
         };
     }
@@ -221,204 +239,210 @@ pub mod test {
             $crate::storage_unit_test!(sorted_unspent_payments);
             $crate::storage_unit_test!(does_not_update_spent_payments);
             $crate::storage_unit_test!(does_not_spend_unspendable_payments);
+            $crate::storage_unit_test!(spend_spendable_payments);
             $crate::storage_unit_test!(relate_account_to_transaction);
-            $crate::storage_unit_test!(pending_new_payments_are_not_spendable);
-            $crate::storage_unit_test!(processing_new_payments_are_not_spendable);
-            $crate::storage_unit_test!(cancelled_new_payments_are_not_spendable);
-            $crate::storage_unit_test!(failed_new_payments_are_not_spendable);
+            $crate::storage_unit_test!(not_spendable_new_payments_not_spendable);
         };
     }
 
-    pub async fn transaction<'a, T>(storage: &'a T, assets: AssetManager)
+    pub async fn transaction<'a, T>(storage: &'a T)
     where
         T: Storage,
     {
+        let asset: Asset = "USD/2".parse().expect("valid asset");
         let deposit = Transaction::new_external_deposit(
             "test reference".to_owned(),
-            Status::Settled,
+            "settled".into(),
             vec![(
                 "alice".parse().expect("account"),
-                assets
-                    .human_amount_by_name("USD", "100.99")
-                    .expect("valid amount"),
+                asset.from_human("100.99").expect("valid amount"),
             )],
         )
         .expect("valid tx");
         let mut storing = storage.begin().await.expect("valid tx");
         storing.store_transaction(&deposit).await.expect("store 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.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<'a, T>(storage: &'a T, assets: AssetManager)
+    pub async fn transaction_not_available_until_commit<'a, T>(storage: &'a T)
     where
         T: Storage,
     {
+        let usd: Asset = "USD/2".parse().expect("valid asset");
         let deposit = Transaction::new_external_deposit(
             "test reference".to_owned(),
-            Status::Settled,
+            "settled".into(),
             vec![(
                 "alice".parse().expect("account"),
-                assets
-                    .human_amount_by_name("USD", "100.99")
-                    .expect("valid amount"),
+                usd.from_human("100.99").expect("valid amount"),
             )],
         )
         .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());
+        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.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<'a, T>(storage: &'a T, assets: AssetManager)
+    pub async fn does_not_update_spent_payments<'a, T>(storage: &'a T)
     where
         T: Storage,
     {
         let mut writer = storage.begin().await.expect("writer");
         let mut rng = rand::thread_rng();
         let account = "account0".parse::<AccountId>().expect("account");
-        let amount = assets
-            .human_amount_by_name("USD", &format!("{}", rng.gen_range(-1000.0..1000.0)))
+        let usd: Asset = "USD/2".parse().expect("valid asset");
+        let amount = usd
+            .from_human(&format!("{}", rng.gen_range(-1000.0..1000.0)))
             .expect("valid amount");
 
-        let payment_id = PaymentId {
-            transaction: vec![0u8; 32].try_into().expect("valid tx id"),
-            position: 0,
+        let transaction_id = vec![0u8; 32].try_into().expect("valid tx id");
+
+        let recipient = PaymentTo {
+            to: account.clone(),
+            amount,
         };
 
+        let recipients = vec![recipient];
+
         writer
-            .store_new_payment(&Payment {
-                id: payment_id.clone(),
-                to: account.clone(),
-                amount,
-                status: Status::Settled,
-                changelog: vec![],
-                spent: None,
-            })
+            .create_payments(&transaction_id, &recipients, Status::Locked)
             .await
             .expect("valid payment");
 
         // Alter state
-        assert!(writer
-            .update_payment(&payment_id, &payment_id.transaction, Status::Processing)
-            .await
-            .is_ok());
-
-        // Alter state, again
-        assert!(writer
-            .update_payment(&payment_id, &payment_id.transaction, Status::Cancelled)
-            .await
-            .is_ok());
+        assert_eq!(
+            writer
+                .update_transaction_payments(&transaction_id, Status::Locked, Status::Locked)
+                .await
+                .expect("valid"),
+            (1, 0)
+        );
 
-        // Payment is forever used
-        assert!(writer
-            .update_payment(&payment_id, &payment_id.transaction, Status::Settled)
-            .await
-            .is_ok());
+        // Transactions is settled and their spent payments are forever spent
+        assert_eq!(
+            writer
+                .update_transaction_payments(&transaction_id, Status::Spent, Status::Spent)
+                .await
+                .expect("valid"),
+            (1, 0)
+        );
 
-        for status in Status::iter() {
-            assert!(
+        for status in [Status::Failed, Status::Spendable] {
+            assert_eq!(
                 writer
-                    .update_payment(&payment_id, &payment_id.transaction, status.clone())
+                    .update_transaction_payments(&transaction_id, status, status)
                     .await
-                    .is_err(),
+                    .expect("valid update"),
+                (0, 0),
                 "status: {:?}",
                 status
             );
         }
     }
 
-    pub async fn pending_new_payments_are_not_spendable<'a, T>(storage: &'a T, assets: AssetManager)
+    pub async fn spend_spendable_payments<'a, T>(storage: &'a T)
     where
         T: Storage,
     {
-        not_spendable_new_payments_not_spendable(storage, assets, Status::Pending).await
-    }
+        let mut writer = storage.begin().await.expect("writer");
+        let mut rng = rand::thread_rng();
+        let account = "account0".parse::<AccountId>().expect("account");
+        let usd: Asset = "USD/2".parse().expect("valid asset");
+        let amount = usd
+            .from_human(&format!("{}", rng.gen_range(-1000.0..1000.0)))
+            .expect("valid amount");
 
-    pub async fn processing_new_payments_are_not_spendable<'a, T>(
-        storage: &'a T,
-        assets: AssetManager,
-    ) where
-        T: Storage,
-    {
-        not_spendable_new_payments_not_spendable(storage, assets, Status::Processing).await
-    }
+        for (i, status) in [Status::Locked, Status::Spendable].into_iter().enumerate() {
+            let transaction_id: TransactionId = vec![i as u8; 32].try_into().expect("valid tx id");
 
-    pub async fn cancelled_new_payments_are_not_spendable<'a, T>(
-        storage: &'a T,
-        assets: AssetManager,
-    ) where
-        T: Storage,
-    {
-        not_spendable_new_payments_not_spendable(storage, assets, Status::Cancelled).await
-    }
+            writer
+                .create_payments(
+                    &transaction_id,
+                    &[PaymentTo {
+                        to: account.clone(),
+                        amount: amount.clone(),
+                    }],
+                    status,
+                )
+                .await
+                .expect("valid payment");
 
-    pub async fn failed_new_payments_are_not_spendable<'a, T>(storage: &'a T, assets: AssetManager)
-    where
-        T: Storage,
-    {
-        not_spendable_new_payments_not_spendable(storage, assets, Status::Failed).await
+            for (spend_new_status, create_new_status) in [(Status::Spent, Status::Spent)] {
+                assert_eq!(
+                    writer
+                        .update_transaction_payments(
+                            &transaction_id,
+                            spend_new_status,
+                            create_new_status
+                        )
+                        .await
+                        .expect("no updates"),
+                    (1, 0)
+                );
+            }
+        }
     }
 
-    pub async fn does_not_spend_unspendable_payments<'a, T>(storage: &'a T, assets: AssetManager)
+    pub async fn does_not_spend_unspendable_payments<'a, T>(storage: &'a T)
     where
         T: Storage,
     {
         let mut writer = storage.begin().await.expect("writer");
         let mut rng = rand::thread_rng();
         let account = "account0".parse::<AccountId>().expect("account");
-        let amount = assets
-            .human_amount_by_name("USD", &format!("{}", rng.gen_range(-1000.0..1000.0)))
+        let usd: Asset = "USD/2".parse().expect("valid asset");
+        let amount = usd
+            .from_human(&format!("{}", rng.gen_range(-1000.0..1000.0)))
             .expect("valid amount");
 
-        for status in Status::iter() {
-            if status == Status::Settled {
-                continue;
-            }
-            let status_id: u32 = status.clone().into();
-            let payment_id = PaymentId {
-                transaction: vec![status_id as u8; 32].try_into().expect("valid tx id"),
-                position: 0,
-            };
+        for (i, status) in [Status::Failed, Status::Spent].into_iter().enumerate() {
+            let transaction_id: TransactionId = vec![i as u8; 32].try_into().expect("valid tx id");
 
             writer
-                .store_new_payment(&Payment {
-                    id: payment_id.clone(),
-                    to: account.clone(),
-                    amount: amount.clone(),
+                .create_payments(
+                    &transaction_id,
+                    &[PaymentTo {
+                        to: account.clone(),
+                        amount: amount.clone(),
+                    }],
                     status,
-                    changelog: vec![],
-                    spent: Some(SpentInfo {
-                        by: payment_id.transaction.clone(),
-                        status: Status::Settled,
-                    }),
-                })
+                )
                 .await
                 .expect("valid payment");
-            for status in Status::iter() {
-                if status != Status::Settled {
-                    assert!(writer
-                        .update_payment(&payment_id, &payment_id.transaction, Status::Pending)
+
+            for (spend_new_status, create_new_status) in [
+                (Status::Spent, Status::Spent),
+                (Status::Spendable, Status::Spendable),
+            ] {
+                assert_eq!(
+                    writer
+                        .update_transaction_payments(
+                            &transaction_id,
+                            spend_new_status,
+                            create_new_status
+                        )
                         .await
-                        .is_err());
-                }
+                        .expect("no updates"),
+                    (0, 0)
+                );
             }
         }
     }
 
-    pub async fn sorted_unspent_payments<'a, T>(storage: &'a T, assets: AssetManager)
+    pub async fn sorted_unspent_payments<'a, T>(storage: &'a T)
     where
         T: Storage,
     {
@@ -428,40 +452,39 @@ pub mod test {
             .collect();
 
         let mut rng = rand::thread_rng();
-        let mut position = 0;
         let target_inputs_per_account = 20;
-
-        for account in &accounts {
-            for _ in 0..target_inputs_per_account {
-                let amount = assets
-                    .human_amount_by_name("USD", &format!("{}", rng.gen_range(-1000.0..1000.0)))
-                    .expect("valid amount");
-                writer
-                    .store_new_payment(&Payment {
-                        id: PaymentId {
-                            transaction: vec![0u8; 32].try_into().expect("valid tx id"),
-                            position,
-                        },
+        let usd: Asset = "USD/2".parse().expect("valid asset");
+
+        for (index, account) in accounts.iter().enumerate() {
+            let transaction_id: TransactionId =
+                vec![index as u8; 32].try_into().expect("valid tx id");
+            let recipients = (0..target_inputs_per_account)
+                .map(|_| {
+                    let amount = usd
+                        .from_human(&format!("{}", rng.gen_range(-1000.0..1000.0)))
+                        .expect("valid amount");
+                    PaymentTo {
                         to: account.clone(),
                         amount,
-                        changelog: vec![],
-                        status: Status::Settled,
-                        spent: None,
-                    })
-                    .await
-                    .expect("valid payment");
-                position += 1;
-            }
+                    }
+                })
+                .collect::<Vec<_>>();
+
+            writer
+                .create_payments(&transaction_id, &recipients, Status::Spendable)
+                .await
+                .expect("valid payment");
         }
         writer.commit().await.expect("valid commit");
+
         let mut at_least_one_negative_amount = false;
         for account in &accounts {
-            let balance = &storage.get_balance(&account).await.expect("valid balance")[0];
+            let balance = &storage.get_balance(account).await.expect("valid balance")[0];
             if balance.cents() < 0 {
                 continue;
             }
             let all_unspent_amounts = storage
-                .get_unspent_payments(account, balance.asset().id, balance.cents())
+                .get_unspent_payments(account, balance.asset(), balance.cents())
                 .await
                 .expect("valid unspent payments")
                 .into_iter()
@@ -480,21 +503,20 @@ pub mod test {
         assert!(at_least_one_negative_amount);
     }
 
-    pub async fn relate_account_to_transaction<'a, T>(storage: &'a T, assets: AssetManager)
+    pub async fn relate_account_to_transaction<'a, T>(storage: &'a T)
     where
         T: Storage,
     {
         let account1: AccountId = "alice1".parse().expect("account");
         let account2: AccountId = "alice2".parse().expect("account");
         let account3: AccountId = "alice3".parse().expect("account");
+        let usd: Asset = "USD/2".parse().expect("USD");
         let deposit = Transaction::new_external_deposit(
             "test reference".to_owned(),
-            Status::Settled,
+            "settled".into(),
             vec![(
                 account1.clone(),
-                assets
-                    .human_amount_by_name("USD", "100.99")
-                    .expect("valid amount"),
+                usd.from_human("100.99").expect("valid amount"),
             )],
         )
         .expect("valid tx");
@@ -502,11 +524,11 @@ pub mod test {
         let mut batch = storage.begin().await.expect("valid tx");
         batch.store_transaction(&deposit).await.expect("is ok");
         batch
-            .relate_account_to_transaction(&deposit, &account1)
+            .relate_account_to_transaction(&deposit.id, &account1, Type::Deposit)
             .await
             .expect("relationship");
         batch
-            .relate_account_to_transaction(&deposit, &account2)
+            .relate_account_to_transaction(&deposit.id, &account2, Type::Deposit)
             .await
             .expect("relationship");
 
@@ -540,7 +562,7 @@ pub mod test {
             assert_eq!(
                 0,
                 storage
-                    .get_transactions(&account, &[Type::Withdrawal], &[])
+                    .get_transactions(account, &[Type::Withdrawal], &[])
                     .await
                     .expect("valid tx")
                     .len()
@@ -548,34 +570,29 @@ pub mod test {
         }
     }
 
-    async fn not_spendable_new_payments_not_spendable<'a, T>(
-        storage: &'a T,
-        assets: AssetManager,
-        status: Status,
-    ) where
+    pub async fn not_spendable_new_payments_not_spendable<'a, T>(storage: &'a T)
+    where
         T: Storage,
     {
         let mut writer = storage.begin().await.expect("writer");
         let mut rng = rand::thread_rng();
         let account = "account0".parse::<AccountId>().expect("account");
-        let amount = assets
-            .human_amount_by_name("USD", &format!("{}", rng.gen_range(10.0..10000.0)))
+        let usd: Asset = "USD/2".parse().expect("valid asset");
+        let amount = usd
+            .from_human(&format!("{}", rng.gen_range(10.0..10000.0)))
             .expect("valid amount");
 
-        let payment_id = PaymentId {
-            transaction: vec![0u8; 32].try_into().expect("valid tx id"),
-            position: 0,
-        };
+        let transaction: TransactionId = vec![0u8; 32].try_into().expect("valid tx id");
 
         writer
-            .store_new_payment(&Payment {
-                id: payment_id.clone(),
-                to: account.clone(),
-                amount,
-                status,
-                changelog: vec![],
-                spent: None,
-            })
+            .create_payments(
+                &transaction,
+                &[PaymentTo {
+                    to: account.clone(),
+                    amount,
+                }],
+                Status::Locked,
+            )
             .await
             .expect("valid payment");
 

utxo/src/storage/sqlite/batch.rs

@@ -1,11 +1,11 @@
 use crate::{
-    changelog::Changelog,
-    storage::{self, Error},
-    AccountId, Payment, PaymentId, Status, Transaction, TransactionId,
+    payment::PaymentTo,
+    storage::{self, Error, Status},
+    transaction::inner::TransactionInner,
+    AccountId, PaymentId, Transaction, TransactionId, Type,
 };
-use serde::{de::DeserializeOwned, Serialize};
 use sqlx::{Row, Sqlite, Transaction as SqlxTransaction};
-use std::marker::PhantomData;
+use std::{marker::PhantomData, num::TryFromIntError};
 
 /// Creates a new Batch for SQLite
 ///
@@ -35,6 +35,57 @@ impl<'a> storage::Batch<'a> for Batch<'a> {
             .map_err(|e| Error::Storage(e.to_string()))
     }
 
+    async fn relate_account_to_transaction(
+        &mut self,
+        transaction: &TransactionId,
+        account: &AccountId,
+        typ: Type,
+    ) -> Result<(), Error> {
+        sqlx::query(
+            r#"
+            INSERT INTO "transaction_accounts" ("transaction_id", "account_id", "type")
+            VALUES (?, ?, ?)
+            "#,
+        )
+        .bind(transaction.to_string())
+        .bind(account.to_string())
+        .bind::<u32>(typ.into())
+        .execute(&mut *self.inner)
+        .await
+        .map_err(|e| Error::Storage(e.to_string()))?;
+        Ok(())
+    }
+
+    async fn get_transaction(
+        &mut self,
+        transaction_id: &TransactionId,
+    ) -> Result<Transaction, Error> {
+        let row = sqlx::query(
+            r#"
+            SELECT
+                "b"."blob"
+            FROM
+                "transactions" as "t",
+                "blobs" as "b"
+            WHERE
+                "t"."transaction_id" = ?
+                AND "t"."blob_id" = "b"."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>(0)
+            .map_err(|e| Error::Storage(e.to_string()))?;
+        bincode::deserialize::<TransactionInner>(&encoded)
+            .map_err(|e| Error::Storage(e.to_string()))?
+            .try_into()
+            .map_err(|e: crate::transaction::Error| Error::Storage(e.to_string()))
+    }
+
     async fn commit(self) -> Result<(), Error> {
         self.inner
             .commit()
@@ -42,82 +93,124 @@ impl<'a> storage::Batch<'a> for Batch<'a> {
             .map_err(|e| Error::Storage(e.to_string()))
     }
 
-    async fn store_changelogs<T: DeserializeOwned + Serialize + Send + Sync>(
+    async fn spend_payments(
         &mut self,
-        changelog: &[Changelog<T>],
+        transaction_id: &TransactionId,
+        spends: Vec<PaymentId>,
+        status: Status,
     ) -> Result<(), Error> {
-        for change in changelog.iter() {
-            let change_bytes =
-                bincode::serialize(&change.change).map_err(|e| Error::Storage(e.to_string()))?;
+        let spend_ids = spends.iter().map(|id| id.to_string()).collect::<Vec<_>>();
+        let placeholder = format!("?{}", ", ?".repeat(spend_ids.len()));
+
+        let sql = format!(
+            r#"
+            UPDATE "payments"
+            SET "status" = ?, "spent_by" = ?
+            WHERE "payment_id" IN ({placeholder})
+            AND "spent_by" IS NULL
+        "#
+        );
+
+        let mut query = sqlx::query(&sql)
+            .bind::<u32>(status.into())
+            .bind(transaction_id.to_string());
 
+        for id in spend_ids {
+            query = query.bind(id);
+        }
+
+        let updated_records = query
+            .execute(&mut *self.inner)
+            .await
+            .map_err(|e| Error::Storage(e.to_string()))?
+            .rows_affected() as usize;
+
+        if updated_records == spends.len() {
+            Ok(())
+        } else {
+            Err(Error::NoUpdate)
+        }
+    }
+
+    async fn create_payments(
+        &mut self,
+        transaction_id: &TransactionId,
+        recipients: &[PaymentTo],
+        status: Status,
+    ) -> Result<(), Error> {
+        for (pos, recipient) in recipients.iter().enumerate() {
             sqlx::query(
                 r#"
-                INSERT INTO "changelog"("id", "previous", "object_id", "change", "created_at")
-                VALUES(?, ?, ?, ?, ?)
-                ON CONFLICT("id")
-                    DO NOTHING
+                INSERT INTO "payments"("payment_id", "to", "status", "asset", "cents")
+                VALUES(?, ?, ?, ?, ? )
             "#,
             )
-            .bind(change.id().map_err(|e| Error::Storage(e.to_string()))?)
-            .bind(&change.previous)
-            .bind(&change.object_id)
-            .bind(change_bytes)
-            .bind(change.updated_at)
+            .bind(
+                PaymentId {
+                    transaction: transaction_id.clone(),
+                    position: pos
+                        .try_into()
+                        .map_err(|e: TryFromIntError| Error::Encoding(e.to_string()))?,
+                }
+                .to_string(),
+            )
+            .bind(recipient.to.to_string())
+            .bind::<u32>(status.into())
+            .bind(recipient.amount.asset().to_string())
+            .bind(recipient.amount.cents().to_string())
             .execute(&mut *self.inner)
             .await
             .map_err(|e| Error::Storage(e.to_string()))?;
         }
+
         Ok(())
     }
 
-    async fn update_payment(
+    async fn update_transaction_payments(
         &mut self,
-        payment_id: &PaymentId,
-        spent_by: &TransactionId,
-        spent_status: Status,
-    ) -> Result<(), Error> {
-        let settled: u32 = Status::Settled.into();
-        let spent_by_val = if spent_status.is_rollback() {
-            None
-        } else {
-            Some(spent_by.to_string())
-        };
-        let spent_by_status_val: Option<u32> = if spent_status.is_rollback() {
-            None
-        } else {
-            Some(spent_status.into())
-        };
+        transaction_id: &TransactionId,
+        create_status: Status,
+        spend_status: Status,
+    ) -> Result<(usize, usize), Error> {
+        let creates = sqlx::query(
+            r#"
+            UPDATE "payments"
+            SET "status" = ?, updated_at = datetime('now')
+            WHERE "payment_id" LIKE ? AND "status" IN (?, ?)
+        "#,
+        )
+        .bind::<u32>(create_status.into())
+        .bind(format!("{}:%", transaction_id.to_string()))
+        .bind::<u32>(Status::Spendable.into())
+        .bind::<u32>(Status::Locked.into())
+        .execute(&mut *self.inner)
+        .await
+        .map_err(|e| Error::Storage(e.to_string()))?;
 
-        let result = sqlx::query(
+        let spends = sqlx::query(
             r#"
-                UPDATE 
-                    "payments" 
-                SET 
-                    "spent_by" = ?,
-                    "spent_by_status" = ?
-                WHERE 
-                    "transaction_id" = ?
-                    AND "position_id" = ?
-                    AND "status" = ? 
-                    AND ("spent_by_status" IS NULL OR "spent_by_status" != ?)
-                    AND ("spent_by" = ? OR "spent_by" IS NULL)
+            UPDATE "payments"
+            SET "status" = ?, "spent_by" = ?, updated_at = datetime('now')
+            WHERE "spent_by" = ? AND "status" IN (?, ?)
             "#,
         )
-        .bind(spent_by_val)
-        .bind(spent_by_status_val)
-        .bind(payment_id.transaction.to_string())
-        .bind(payment_id.position.to_string())
-        .bind(settled)
-        .bind(settled)
-        .bind(spent_by.to_string())
+        .bind::<u32>(spend_status.into())
+        .bind(if spend_status == Status::Spendable {
+            None
+        } else {
+            Some(transaction_id.to_string())
+        })
+        .bind(transaction_id.to_string())
+        .bind::<u32>(Status::Spendable.into())
+        .bind::<u32>(Status::Locked.into())
         .execute(&mut *self.inner)
         .await
-        .map_err(|e| Error::SpendPayment(e.to_string()))?;
-        if result.rows_affected() == 1 {
-            Ok(())
-        } else {
-            Err(Error::NoUpdate)
-        }
+        .map_err(|e| Error::Storage(e.to_string()))?;
+
+        Ok((
+            creates.rows_affected() as usize,
+            spends.rows_affected() as usize,
+        ))
     }
 
     async fn get_payment_status(
@@ -131,7 +224,7 @@ impl<'a> storage::Batch<'a> for Batch<'a> {
             FROM
                 "payments" "p"
             WHERE
-                "p"."transaction_id" = ?
+                "p"."payment_id" = ?
             LIMIT 1
             "#,
         )
@@ -147,139 +240,52 @@ impl<'a> storage::Batch<'a> for Batch<'a> {
 
             status
                 .try_into()
-                .map(|x| Some(x))
+                .map(Some)
                 .map_err(|_| Error::Storage("failed to parse status".to_owned()))
         } else {
             return Ok(None);
         }
     }
 
-    async fn store_new_payment(&mut self, payment: &Payment) -> Result<(), Error> {
-        sqlx::query(
-                r#"
-                INSERT INTO payments("transaction_id", "position_id", "to", "cents", "asset_id", "status", "spent_by_status")
-                VALUES (?, ?, ?, ?, ?, ?, ?)
-                ON CONFLICT("transaction_id", "position_id")
-                    DO UPDATE SET "status" = excluded."status"
-            "#,
-            )
-            .bind(payment.id.transaction.to_string())
-            .bind(payment.id.position.to_string())
-            .bind(payment.to.to_string())
-            .bind(payment.amount.cents().to_string())
-            .bind(payment.amount.asset().id)
-            .bind::<u32>((&payment.status).into())
-            .bind::<Option<u32>>(None)
-            .execute(&mut *self.inner)
-            .await
-            .map_err(|e| Error::Storage(e.to_string()))?;
-        Ok(())
-    }
-
     async fn store_transaction(&mut self, transaction: &Transaction) -> Result<(), Error> {
         sqlx::query(
             r#"
-                INSERT INTO "transactions"("transaction_id", "status", "type", "reference", "last_version", "created_at", "updated_at")
-                VALUES(?, ?, ?, ?, ?, ?, ?)
-                ON CONFLICT("transaction_id")
-                    DO UPDATE SET "status" = excluded."status", "updated_at" = excluded."updated_at", "last_version" = excluded."last_version"
+                INSERT INTO "blobs"("id", "transaction_id", "blob", "status", "created_at")
+                VALUES(?, ?, ?, ?, ?)
             "#,
         )
-        .bind(transaction.id().to_string())
-        .bind::<u32>(transaction.status().into())
-        .bind::<u32>(transaction.typ().into())
-        .bind(transaction.reference())
-        .bind(transaction.last_version())
+        .bind(transaction.revision.to_string())
+        .bind(transaction.id.to_string())
+        .bind(bincode::serialize(transaction.inner()).map_err(|e| Error::Encoding(e.to_string()))?)
+        .bind(transaction.status().to_string())
         .bind(transaction.created_at())
-        .bind(transaction.updated_at())
         .execute(&mut *self.inner)
         .await
         .map_err(|e| Error::Storage(e.to_string()))?;
 
-        for payment in transaction.spends().iter() {
-            sqlx::query(
-                r#"
-            INSERT INTO "transaction_input_payments"("transaction_id", "payment_transaction_id", "payment_position_id")
-            VALUES(?, ?, ?)
-            ON CONFLICT("transaction_id", "payment_transaction_id", "payment_position_id")
-                DO NOTHING
-            "#,
-            )
-            .bind(transaction.id().to_string())
-            .bind(payment.id.transaction.to_string())
-            .bind(payment.id.position.to_string())
-            .execute(&mut *self.inner)
-            .await
-            .map_err(|e| Error::Storage(e.to_string()))?;
-        }
-
-        Ok(())
-    }
-
-    async fn tag_transaction(
-        &mut self,
-        transaction: &Transaction,
-        tags: &[String],
-    ) -> Result<(), Error> {
-        for tag in tags.iter() {
-            sqlx::query(
-                r#"
-        INSERT INTO "transaction_tags"("transaction_id", "tag", "status", "type")
-        VALUES(?, ?, ?, ?)
-        ON CONFLICT("transaction_id", "tag")
-            DO NOTHING
-        "#,
-            )
-            .bind(transaction.id().to_string())
-            .bind(tag)
-            .bind::<u32>(transaction.status().into())
-            .bind::<u32>(transaction.typ().into())
-            .execute(&mut *self.inner)
-            .await
-            .map_err(|e| Error::Storage(e.to_string()))?;
-        }
-
-        let delete_tags = if tags.is_empty() {
-            r#"DELETE FROM "transaction_tags" WHERE "transaction_id" = ?"#.to_owned()
-        } else {
-            format!(
-                r#"DELETE FROM "transaction_tags" WHERE "transaction_id" = ? AND tag NOT IN (?{})"#,
-                ", ?".repeat(tags.len() - 1)
-            )
-        };
-
-        let mut sql = sqlx::query(&delete_tags).bind(transaction.id().to_string());
-        for tag in tags.iter() {
-            sql = sql.bind(tag);
-        }
-
-        sql.execute(&mut *self.inner)
-            .await
-            .map_err(|e| Error::Storage(e.to_string()))?;
-        Ok(())
-    }
-
-    async fn relate_account_to_transaction(
-        &mut self,
-        transaction: &Transaction,
-        account: &AccountId,
-    ) -> Result<(), Error> {
         sqlx::query(
             r#"
-            INSERT INTO "transaction_accounts"("transaction_id", "account_id", "type", "created_at", "updated_at")
-            VALUES(?, ?, ?, ?, ?)
-            ON CONFLICT("transaction_id", "account_id")
-                DO NOTHING
+                INSERT INTO "transactions"("transaction_id", "blob_id", "status")
+                VALUES(?, ?, ?)
+                ON CONFLICT("transaction_id")
+                    DO UPDATE SET "blob_id" = EXCLUDED."blob_id", "status" = EXCLUDED."status"
             "#,
         )
-        .bind(transaction.id().to_string())
-        .bind(account.to_string())
-        .bind::<u32>(transaction.typ().into())
-        .bind(transaction.created_at())
-        .bind(transaction.updated_at())
+        .bind(transaction.id.to_string())
+        .bind(transaction.revision.to_string())
+        .bind(transaction.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,
+        _tags: &[String],
+    ) -> Result<(), Error> {
+        todo!()
+    }
 }

utxo/src/storage/sqlite/mod.rs

@@ -1,100 +1,75 @@
 //! SQLite storage layer for Verax
 use crate::{
     amount::AmountCents,
-    asset::AssetId,
-    changelog::Changelog,
-    payment::{self, SpentInfo},
     storage::{Error, Storage},
-    transaction::{self, from_db, Type},
-    AccountId, Amount, Asset, AssetManager, Payment, PaymentId, Status, TransactionId,
+    transaction::{inner::TransactionInner, Type},
+    AccountId, Amount, Asset, PaymentFrom, PaymentId, Transaction, TransactionId,
 };
-use chrono::NaiveDateTime;
 use futures::TryStreamExt;
-use serde::{de::DeserializeOwned, Serialize};
-use sqlx::{sqlite::SqliteRow, Executor, Row, SqliteConnection};
-use std::{collections::HashMap, ops::Deref};
+use sqlx::{sqlite::SqliteRow, Executor, Row};
+use std::collections::HashMap;
 
 mod batch;
 
 pub use batch::Batch;
 pub use sqlx::sqlite::{SqliteConnectOptions, SqlitePoolOptions};
 
+use super::Status;
+
 /// SQLite storage layer for Verax
 pub struct SQLite {
     db: sqlx::SqlitePool,
-    asset_manager: AssetManager,
 }
 
 impl SQLite {
     /// Creates a new Verax SQLite storage layer. It takes an instance of the asset_manager
-    pub fn new(db: sqlx::SqlitePool, asset_manager: AssetManager) -> Self {
-        Self { db, asset_manager }
+    pub fn new(db: sqlx::SqlitePool) -> Self {
+        Self { db }
     }
 
     /// Creates all the tables and indexes that are needed
+    /// The database uses string for the primary keys to make things easier to debug[1]
+    ///
+    /// [1] https://sqlite.org/forum/info/69c8cbbe2d84410f
     pub async fn setup(&self) -> Result<(), sqlx::Error> {
         let mut x = self.db.begin().await?;
         x.execute(
-            r#"CREATE TABLE IF NOT EXISTS "payments" (
-                "transaction_id" VARCHAR(66) NOT NULL,
-                "position_id" INTEGER NOT NULL,
-                "asset_id" TEXT NOT NULL,
-                "cents" BIG INTEGER NOT NULL,
-                "status" INTEGER NOT NULL,
-                "to" VARCHAR(71) NOT NULL,
-                "spent_by" TEXT,
-                "spent_by_status" INTEGER DEFAULT NULL,
-                "created_at" DATETIME DEFAULT CURRENT_TIMESTAMP,
-                "updated_at" DATETIME DEFAULT CURRENT_TIMESTAMP,
-                PRIMARY KEY ("transaction_id", "position_id")
-            );
-            CREATE INDEX IF NOT EXISTS payments_to ON payments ("to", "asset_id", "spent_by", "status");
-            CREATE TABLE IF NOT EXISTS "transactions" (
-                "transaction_id" VARCHAR(66) NOT NULL,
-                "status" INTEGER NOT NULL,
-                "type" INTEGER NOT NULL,
-                "reference" TEXT NOT NULL,
-                "last_version" BLOB NOT NULL,
-                "created_at" DATETIME DEFAULT CURRENT_TIMESTAMP,
-                "updated_at" DATETIME DEFAULT CURRENT_TIMESTAMP,
-                PRIMARY KEY ("transaction_id")
-            );
-            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 IF NOT EXISTS "type" ON "transaction_accounts" ("account_id", "type", "created_at" DESC);
-            CREATE TABLE IF NOT EXISTS "transaction_input_payments" (
-                "transaction_id" VARCHAR(66) NOT NULL,
-                "payment_transaction_id" VARCHAR(66) NOT NULL,
-                "payment_position_id"  INTEGER NOT NULL,
-                "created_at" DATETIME DEFAULT CURRENT_TIMESTAMP,
-                "updated_at" DATETIME DEFAULT CURRENT_TIMESTAMP,
-                PRIMARY KEY ("transaction_id", "payment_transaction_id", "payment_position_id")
-            );
-            CREATE TABLE IF NOT EXISTS "changelog" (
-                "id" BLOB NOT NULL,
-                "object_id" BLOB NOT NULL,
-                "previous" BLOB DEFAULT NULL,
-                "change" BLOB NOT NULL,
-                "created_at" DATETIME DEFAULT CURRENT_TIMESTAMP,
-                PRIMARY KEY ("id")
-            );
-            CREATE INDEX IF NOT EXISTS "changelog_object_id" ON "changelog" ("object_id", "created_at");
-            CREATE TABLE IF NOT EXISTS "transaction_tags" (
-                "transaction_id" VARCHAR(66) NOT NULL,
-                "tag" TEXT NOT NULL,
-                "type" INTEGER NOT NULL,
-                "status" INTEGER NOT NULL,
-                "created_at" DATETIME DEFAULT CURRENT_TIMESTAMP,
-                "updated_at" DATETIME DEFAULT CURRENT_TIMESTAMP,
-                PRIMARY KEY ("transaction_id", "tag")
-            );
-            CREATE INDEX IF NOT EXISTS "tags_index" ON "transaction_tags" ("tag", "type", "status");
+            r#"
+        CREATE TABLE IF NOT EXISTS "transactions" (
+            "transaction_id" VARCHAR(66) NOT NULL PRIMARY KEY,
+            "blob_id" VARCHAR(66) NOT NULL,
+            "status" VARCHAR(10) NOT NULL,
+            "created_at" DATETIME DEFAULT CURRENT_TIMESTAMP,
+            "updated_at" DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
+        CREATE TABLE IF NOT EXISTS "blobs" (
+            "id" VARCHAR(64) NOT NULL PRIMARY KEY,
+            "transaction_id" VARCHAR(66) NOT NULL,
+            "previous_blob_id" BLOB,
+            "status" VARCHAR(30) NOT NULL,
+            "blob" BINARY NOT NULL,
+            "created_at" DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
+        CREATE TABLE IF NOT EXISTS "payments" (
+            "payment_id" VARCHAR(70) NOT NULL PRIMARY KEY,
+            "to" VARCHAR(255) NOT NULL,
+            "status" INT NOT NULL,
+            "asset" VARCHAR(10) NOT NULL,
+            "cents" STRING NOT NULL,
+            "spent_by" VARCHAR(64) DEFAULT NULL,
+            "created_at" DATETIME DEFAULT CURRENT_TIMESTAMP,
+            "updated_at" DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
+        CREATE INDEX IF NOT EXISTS "spent_by" ON "payments" ("to", "spent_by");
+        CREATE TABLE IF NOT EXISTS "transaction_accounts" (
+            "account_id" VARCHAR(64) NOT NULL,
+            "transaction_id" VARCHAR(66) NOT NULL,
+            "type" INTEGE
+            R NOT NULL,
+            "created_at" DATETIME DEFAULT CURRENT_TIMESTAMP,
+            "updated_at" DATETIME DEFAULT CURRENT_TIMESTAMP,
+            PRIMARY KEY("account_id", "transaction_id")
+        );
         "#,
         )
         .await
@@ -103,138 +78,28 @@ impl SQLite {
         Ok(())
     }
 
-    #[inline]
-    async fn get_tags(
-        &self,
-        conn: &mut SqliteConnection,
-        transaction: &TransactionId,
-    ) -> Result<Vec<String>, Error> {
-        Ok(
-            sqlx::query(r#"SELECT tag FROM "transaction_tags" WHERE "transaction_id"=?"#)
-                .bind(transaction.to_string())
-                .fetch_all(&mut *conn)
-                .await
-                .map_err(|e| Error::Storage(e.to_string()))?
-                .into_iter()
-                .map(|x| x.try_get::<String, usize>(0))
-                .collect::<Result<Vec<_>, _>>()
-                .map_err(|e| Error::Storage(e.to_string()))?,
-        )
-    }
-
-    #[inline]
-    async fn get_changelogs_internal<T: DeserializeOwned + Serialize + Send + Sync>(
-        &self,
-        conn: &mut SqliteConnection,
-        object_id: Vec<u8>,
-    ) -> Result<Vec<Changelog<T>>, Error> {
-        let rows = sqlx::query(
-            r#"SELECT  "previous", "change", "created_at", "id" FROM "changelog" WHERE "object_id" = ? ORDER BY "created_at" ASC"#,
-        ).bind(&object_id).fetch_all(&mut *conn).await.map_err(|e| Error::Storage(e.to_string()))?;
-
-        let mut results = vec![];
-
-        for row in rows.into_iter() {
-            let change: T = bincode::deserialize(
-                &row.try_get::<Vec<u8>, usize>(1)
-                    .map_err(|_| Error::Storage("Invalid change content".to_string()))?,
-            )
-            .map_err(|e| Error::Storage(e.to_string()))?;
-            let created_at = row
-                .try_get::<NaiveDateTime, usize>(2)
-                .map_err(|e| Error::InvalidDate(e.to_string()))?
-                .and_utc();
-
-            results.push(Changelog::new_from_db(
-                row.try_get::<Option<Vec<u8>>, usize>(0)
-                    .map_err(|_| Error::Storage("Invalid previous content".to_string()))?,
-                object_id.clone(),
-                change,
-                created_at,
-            ));
-        }
-
-        Ok(results)
-    }
-
-    #[inline]
-    async fn sql_row_to_payment(
-        &self,
-        conn: &mut SqliteConnection,
-        row: SqliteRow,
-    ) -> Result<Payment, Error> {
-        let id = PaymentId {
-            transaction: row
-                .try_get::<String, usize>(0)
-                .map_err(|_| Error::Storage("Invalid payment_id".to_string()))?
-                .as_str()
-                .try_into()
-                .map_err(|_| Error::Storage("Invalid transaction_id length".to_string()))?,
-            position: row
-                .try_get::<i64, usize>(1)
-                .map_err(|_| Error::Storage("Invalid payment_id".to_string()))?
-                .try_into()
-                .map_err(|_| Error::Storage("Invalid payment_id".to_string()))?,
-        };
+    fn sql_row_to_amount(row: &SqliteRow, pos: usize) -> Result<Amount, Error> {
+        let asset: Asset = row
+            .try_get::<String, usize>(pos)
+            .map_err(|_| Error::Storage("Invalid asset".to_string()))?
+            .parse()
+            .map_err(|_| Error::Storage("Invalid asset".to_string()))?;
 
         let cents = row
-            .try_get::<i64, usize>(3)
+            .try_get::<i64, usize>(pos + 1)
             .map_err(|_| Error::Storage("Invalid cents".to_string()))?
-            .into();
-
-        let changelog = self
-            .get_changelogs_internal::<payment::ChangelogEntry>(conn, id.bytes().to_vec())
-            .await?;
-
-        let spent_by: Option<TransactionId> = row
-            .try_get::<Option<String>, usize>(6)
-            .map_err(|_| Error::Storage("Invalid spent_by".to_string()))?
-            .map(|s| s.as_str().try_into())
-            .transpose()
-            .map_err(|_| Error::Storage("Invalid spent_by".to_string()))?;
-
-        let spent_status = row
-            .try_get::<Option<u32>, usize>(7)
-            .map_err(|_| Error::Storage("Invalid spent_by_status".to_string()))?
-            .map(|status| Status::try_from(status))
-            .transpose()
-            .map_err(|_| Error::Storage("Invalid spent_by_status".to_string()))?;
-
-        if spent_by.is_some() != spent_status.is_some() {
-            return Err(Error::Storage(
-                "Invalid spent_by and spent_by_status combination".to_string(),
-            ));
-        }
+            .try_into()
+            .map_err(|_| Error::Storage("Invalid cents".to_string()))?;
 
-        Ok(Payment {
-            id,
-            amount: self
-                .asset_manager
-                .asset(
-                    row.try_get::<String, usize>(2)
-                        .map_err(|_| Error::Storage("Invalid asset_id".to_string()))?
-                        .parse()
-                        .map_err(|_| Error::Storage("Invalid asset_id".to_string()))?,
-                )
-                .map_err(|e| Error::Storage(e.to_string()))?
-                .new_amount(cents),
-            to: row
-                .try_get::<String, usize>(4)
-                .map_err(|_| Error::Storage("Invalid `to`".to_string()))?
-                .as_str()
-                .try_into()
-                .map_err(|_| Error::Storage("Invalid `to`".to_string()))?,
-            status: row
-                .try_get::<u32, usize>(5)
-                .map_err(|_| Error::Storage("Invalid `status`".to_string()))?
-                .try_into()
-                .map_err(|_| Error::Storage("Invalid status".to_string()))?,
-            changelog,
-            spent: spent_by.map(|status| SpentInfo {
-                by: status,
-                status: spent_status.unwrap_or_default(),
-            }),
-        })
+        Ok(asset.new_amount(cents))
+    }
+
+    fn sql_row_to_payment_id(row: &SqliteRow, pos: usize) -> Result<PaymentId, Error> {
+        row.try_get::<String, usize>(pos)
+            .map_err(|_| Error::Storage("Invalid payment_id".to_string()))?
+            .as_str()
+            .parse()
+            .map_err(|_| Error::Storage("Invalid payment_id length".to_string()))
     }
 }
 
@@ -248,46 +113,10 @@ impl Storage for SQLite {
         self.db
             .begin()
             .await
-            .map(|x| Batch::new(x))
+            .map(Batch::new)
             .map_err(|x| Error::Storage(x.to_string()))
     }
 
-    async fn get_payment(&self, id: &PaymentId) -> Result<Payment, Error> {
-        let mut conn = self
-            .db
-            .acquire()
-            .await
-            .map_err(|e| Error::Storage(e.to_string()))?;
-
-        let row = sqlx::query(
-            r#"
-            SELECT
-                "p"."transaction_id",
-                "p"."position_id",
-                "p"."asset_id",
-                "p"."cents",
-                "p"."to",
-                "p"."status",
-                "p"."spent_by",
-                "p"."spent_by_status"
-            FROM
-                "payments" "p"
-            WHERE
-                "p"."transaction_id" = ?
-                AND "p"."position_id" = ?
-            LIMIT 1
-            "#,
-        )
-        .bind(id.transaction.to_string())
-        .bind(id.position.to_string())
-        .fetch_optional(&mut *conn)
-        .await
-        .map_err(|e| Error::Storage(e.to_string()))?
-        .ok_or(Error::NotFound)?;
-
-        Ok(self.sql_row_to_payment(&mut *conn, row).await?)
-    }
-
     async fn get_balance(&self, account: &AccountId) -> Result<Vec<Amount>, Error> {
         let mut conn = self
             .db
@@ -298,17 +127,17 @@ impl Storage for SQLite {
         let mut result = sqlx::query(
             r#"
             SELECT
-                "asset_id",
+                "asset",
                 SUM("cents") as "cents"
             FROM
                 "payments"
             WHERE
-                "to" = ? AND "spent_by" IS NULL AND status = ? 
+                "to" = ? AND "spent_by" IS NULL AND status = ?
             GROUP BY "asset_id"
             "#,
         )
         .bind(account.to_string())
-        .bind::<u32>(Status::Settled.into())
+        .bind::<u32>(Status::Spendable.into())
         .fetch(&mut *conn);
 
         let mut balances = HashMap::<Asset, Amount>::new();
@@ -318,15 +147,11 @@ impl Storage for SQLite {
             .await
             .map_err(|e| Error::Storage(e.to_string()))?
         {
-            let asset = self
-                .asset_manager
-                .asset(
-                    row.try_get::<String, usize>(0)
-                        .map_err(|_| Error::Storage("Invalid asset_id".to_string()))?
-                        .parse()
-                        .map_err(|_| Error::Storage("Invalid asset_id".to_string()))?,
-                )
-                .map_err(|e| Error::Storage(e.to_string()))?;
+            let asset: Asset = row
+                .try_get::<String, usize>(0)
+                .map_err(|_| Error::Storage("Invalid asset_id".to_string()))?
+                .parse()
+                .map_err(|_| Error::Storage("Invalid asset_id".to_string()))?;
 
             let cents = row
                 .try_get::<i64, usize>(1)
@@ -344,15 +169,15 @@ impl Storage for SQLite {
             }
         }
 
-        Ok(balances.into_iter().map(|(_, v)| v).collect())
+        Ok(balances.into_values().collect())
     }
 
     async fn get_unspent_payments(
         &self,
         account: &AccountId,
-        asset: AssetId,
+        asset: &Asset,
         mut target_amount: AmountCents,
-    ) -> Result<Vec<Payment>, Error> {
+    ) -> Result<Vec<PaymentFrom>, Error> {
         let mut conn = self
             .db
             .acquire()
@@ -361,33 +186,37 @@ impl Storage for SQLite {
         let results = sqlx::query(
             r#"
             SELECT
-                "p"."transaction_id",
-                "p"."position_id",
-                "p"."asset_id",
+                "p"."payment_id",
+                "p"."asset",
                 "p"."cents",
-                "p"."to",
-                "p"."status",
-                "p"."spent_by",
-                "p"."spent_by_status"
+                "p"."to"
             FROM
                 "payments" as "p"
             WHERE
-                "p"."to" = ? AND "p"."asset_id" = ? AND status = ? AND "p"."spent_by" IS NULL
+                "p"."to" = ? AND "p"."asset" = ? AND status = ? AND "p"."spent_by" IS NULL
             ORDER BY cents ASC
             "#,
         )
         .bind(account.to_string())
         .bind(asset.to_string())
-        .bind::<u32>(Status::Settled.into())
+        .bind::<u32>(Status::Spendable.into())
         .fetch_all(&mut *conn)
         .await
         .map_err(|e| Error::Storage(e.to_string()))?;
 
         let mut to_return = vec![];
         for row in results.into_iter() {
-            let row = self.sql_row_to_payment(&mut *conn, row).await?;
-            target_amount -= row.amount.cents();
-            to_return.push(row);
+            let amount = Self::sql_row_to_amount(&row, 1)?;
+            target_amount -= amount.cents();
+            to_return.push(PaymentFrom {
+                id: Self::sql_row_to_payment_id(&row, 0)?,
+                from: row
+                    .try_get::<String, usize>(3)
+                    .map_err(|_| Error::Storage("Invalid from".to_string()))?
+                    .parse()
+                    .map_err(|_| Error::Encoding("Invalid account encoding".to_owned()))?,
+                amount,
+            });
             if target_amount <= 0 {
                 break;
             }
@@ -400,147 +229,38 @@ impl Storage for SQLite {
         }
     }
 
-    async fn get_transaction(
-        &self,
-        transaction_id: &TransactionId,
-    ) -> Result<from_db::Transaction, Error> {
+    async fn get_transaction(&self, transaction_id: &TransactionId) -> Result<Transaction, Error> {
         let mut conn = self
             .db
             .acquire()
             .await
             .map_err(|e| Error::Storage(e.to_string()))?;
 
-        let transaction_row = sqlx::query(
+        let row = sqlx::query(
             r#"
             SELECT
-                "t"."status",
-                "t"."type",
-                "t"."reference",
-                "t"."last_version",
-                "t"."created_at",
-                "t"."updated_at"
+                "b"."blob"
             FROM
-                "transactions" "t"
+                "transactions" as "t",
+                "blobs" as "b"
             WHERE
                 "t"."transaction_id" = ?
-            "#,
-        )
-        .bind(transaction_id.to_string())
-        .fetch_optional(&mut *conn)
-        .await
-        .map_err(|e| Error::Storage(e.to_string()))?
-        .ok_or(Error::NotFound)?;
-
-        let results = sqlx::query(
-            r#"
-            SELECT
-                "p"."transaction_id",
-                "p"."position_id",
-                "p"."asset_id",
-                "p"."cents",
-                "p"."to",
-                "p"."status",
-                "p"."spent_by",
-                "p"."spent_by_status"
-            FROM
-                "transaction_input_payments" "tp"
-            INNER JOIN
-                "payments" "p"
-                ON (
-                    "tp"."payment_transaction_id" = "p"."transaction_id"
-                    AND "tp"."payment_position_id" = "p"."position_id"
-                )
-            WHERE
-                "tp"."transaction_id" = ?
-            "#,
-        )
-        .bind(transaction_id.to_string())
-        .fetch_all(&mut *conn)
-        .await
-        .map_err(|e| Error::Storage(e.to_string()))?;
-
-        let mut spend = vec![];
-        for row in results.into_iter() {
-            spend.push(self.sql_row_to_payment(&mut *conn, row).await?);
-        }
-
-        let results = sqlx::query(
-            r#"
-            SELECT
-                "p"."transaction_id",
-                "p"."position_id",
-                "p"."asset_id",
-                "p"."cents",
-                "p"."to",
-                "p"."status",
-                "p"."spent_by",
-                "p"."spent_by_status"
-            FROM
-                "payments" "p"
-            WHERE
-                "p"."transaction_id" = ?
-            "#,
+                AND "t"."blob_id" = "b"."id"
+        "#,
         )
         .bind(transaction_id.to_string())
-        .fetch_all(&mut *conn)
+        .fetch_one(&mut *conn)
         .await
         .map_err(|e| Error::Storage(e.to_string()))?;
 
-        let mut create = vec![];
-
-        for row in results.into_iter() {
-            create.push(self.sql_row_to_payment(&mut *conn, row).await?);
-        }
+        let encoded = row
+            .try_get::<Vec<u8>, usize>(0)
+            .map_err(|e| Error::Storage(e.to_string()))?;
 
-        let status = transaction_row
-            .try_get::<u32, usize>(0)
-            .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()))?
+        bincode::deserialize::<TransactionInner>(&encoded)
+            .map_err(|e| Error::Storage(e.to_string()))?
             .try_into()
-            .map_err(|_| Error::Storage("Invalid type".to_string()))?;
-
-        let reference = transaction_row
-            .try_get::<String, usize>(2)
-            .map_err(|_| Error::Storage("Invalid reference".to_string()))?;
-
-        let last_change = transaction_row
-            .try_get::<Vec<u8>, usize>(3)
-            .map_err(|_| Error::Storage("Invalid last_version".to_string()))?;
-
-        let created_at = transaction_row
-            .try_get::<NaiveDateTime, usize>(4)
-            .map_err(|e| Error::InvalidDate(e.to_string()))?
-            .and_utc();
-
-        let updated_at = transaction_row
-            .try_get::<NaiveDateTime, usize>(5)
-            .map_err(|e| Error::InvalidDate(e.to_string()))?
-            .and_utc();
-
-        let changelog = self
-            .get_changelogs_internal::<transaction::ChangelogEntry>(
-                &mut *conn,
-                transaction_id.deref().to_vec(),
-            )
-            .await?;
-
-        Ok(from_db::Transaction {
-            id: transaction_id.clone(),
-            spend,
-            create,
-            typ,
-            tags: self.get_tags(&mut *conn, transaction_id).await?,
-            last_change,
-            changelog,
-            status,
-            reference,
-            created_at,
-            updated_at,
-        })
+            .map_err(|e: crate::transaction::Error| Error::Storage(e.to_string()))
     }
 
     async fn get_transactions(
@@ -548,7 +268,7 @@ impl Storage for SQLite {
         account: &AccountId,
         types: &[Type],
         _tags: &[String],
-    ) -> Result<Vec<from_db::Transaction>, Error> {
+    ) -> Result<Vec<Transaction>, Error> {
         let mut conn = self
             .db
             .acquire()
@@ -569,7 +289,7 @@ impl Storage for SQLite {
 
         let ids = if !types.is_empty() {
             let mut sql = sql;
-            for typ in types.into_iter() {
+            for typ in types.iter() {
                 sql = sql.bind::<u32>(typ.into());
             }
             sql
@@ -579,7 +299,7 @@ impl Storage for SQLite {
         .fetch_all(&mut *conn)
         .await
         .map_err(|e| Error::Storage(e.to_string()))?
-        .iter()
+        .into_iter()
         .map(|row| {
             let id: Result<TransactionId, _> = row
                 .try_get::<String, usize>(0)
@@ -600,29 +320,16 @@ impl Storage for SQLite {
 
         Ok(transactions)
     }
-
-    async fn get_changelogs<T: DeserializeOwned + Serialize + Send + Sync>(
-        &self,
-        object_id: Vec<u8>,
-    ) -> Result<Vec<Changelog<T>>, Error> {
-        let mut conn = self
-            .db
-            .acquire()
-            .await
-            .map_err(|e| Error::Storage(e.to_string()))?;
-
-        self.get_changelogs_internal(&mut *conn, object_id).await
-    }
 }
 
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::{storage_test_suite, AssetDefinition};
+    use crate::storage_test_suite;
     use sqlx::sqlite::{SqliteConnectOptions, SqlitePoolOptions};
     use std::fs::remove_file;
 
-    async fn get_instance(assets: AssetManager, test: &str) -> SQLite {
+    async fn get_instance(test: &str) -> SQLite {
         let path = format!("/tmp/{}.db", test);
         let _ = remove_file(&path);
         let settings = path
@@ -635,7 +342,7 @@ mod test {
             .await
             .expect("pool");
 
-        let db = SQLite::new(pool, assets);
+        let db = SQLite::new(pool);
         db.setup().await.expect("setup");
         db
     }

utxo/src/tests/deposit.rs

@@ -1,15 +1,16 @@
 use super::{deposit, get_asset_manager_and_ledger};
-use crate::{AccountId, Status};
+use crate::{AccountId, Asset};
 
 #[tokio::test]
 async fn pending_deposit_and_failure() {
     let source = "account1".parse::<AccountId>().expect("account");
-    let (assets, ledger) = get_asset_manager_and_ledger().await;
+    let ledger = get_asset_manager_and_ledger().await;
+    let usd: Asset = "USD/2".parse().expect("asset");
     let id = ledger
         .deposit(
             &source,
-            assets.amount_by_and_cents(2, 3000).expect("amount"),
-            Status::Processing,
+            usd.from_human("30").expect("amount"),
+            "processing".into(),
             "Test".to_owned(),
         )
         .await
@@ -24,7 +25,7 @@ async fn pending_deposit_and_failure() {
         .is_empty());
 
     ledger
-        .change_status(&id, Status::Failed, "failed due test".to_owned())
+        .change_status(&id, "failed".into(), "failed due test".to_owned())
         .await
         .expect("valid tx");
 
@@ -40,58 +41,40 @@ async fn deposit_and_transfer() {
     let source = "account1".parse::<AccountId>().expect("account");
     let dest = "account2".parse::<AccountId>().expect("account");
     let fee = "fee".parse::<AccountId>().expect("account");
-    let (assets, ledger) = get_asset_manager_and_ledger().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;
+    let ledger = get_asset_manager_and_ledger().await;
+    let usd: Asset = "USD/2".parse().expect("asset");
+
+    deposit(&ledger, &source, usd.from_human("10").expect("amount")).await;
+    deposit(&ledger, &source, usd.from_human("20").expect("amount")).await;
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 3000).expect("amount")],
+        vec![usd.from_human("30").expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
 
     ledger
         .new_transaction(
             "Exchange one".to_owned(),
-            Status::Settled,
-            vec![(
-                source.clone(),
-                assets.amount_by_and_cents(2, 1300).expect("amount"),
-            )],
+            "settled".into(),
+            vec![(source.clone(), usd.from_human("13").expect("amount"))],
             vec![
-                (
-                    dest.clone(),
-                    assets.amount_by_and_cents(2, 1250).expect("amount"),
-                ),
-                (
-                    fee.clone(),
-                    assets.amount_by_and_cents(2, 50).expect("amount"),
-                ),
+                (dest.clone(), usd.from_human("12.5").expect("amount")),
+                (fee.clone(), usd.from_human("0.5").expect("amount")),
             ],
         )
         .await
         .expect("valid tx");
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
+        vec![usd.from_human("17").expect("amount"),],
         ledger.get_balance(&source).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 1250).expect("amount")],
+        vec![usd.from_human("12.5").expect("amount"),],
         ledger.get_balance(&dest).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 50).expect("amount")],
+        vec![usd.from_human("0.5").expect("amount"),],
         ledger.get_balance(&fee).await.expect("balance")
     );
 }
@@ -101,43 +84,25 @@ async fn balance_decreases_while_pending_spending_and_confirm() {
     let source = "account1".parse::<AccountId>().expect("account");
     let dest = "account2".parse::<AccountId>().expect("account");
     let fee = "fee".parse::<AccountId>().expect("account");
-    let (assets, ledger) = get_asset_manager_and_ledger().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;
+    let ledger = get_asset_manager_and_ledger().await;
+    let usd: Asset = "USD/2".parse().expect("asset");
+
+    deposit(&ledger, &source, usd.from_human("10").expect("amount")).await;
+    deposit(&ledger, &source, usd.from_human("20").expect("amount")).await;
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 3000).expect("amount")],
+        vec![usd.from_human("30").expect("amount"),],
         ledger.get_balance(&source).await.expect("balance")
     );
 
     let id = ledger
         .new_transaction(
             "Exchange one".to_owned(),
-            Status::Pending,
-            vec![(
-                source.clone(),
-                assets.amount_by_and_cents(2, 1300).expect("amount"),
-            )],
+            "pending".into(),
+            vec![(source.clone(), usd.from_human("13").expect("amount"))],
             vec![
-                (
-                    dest.clone(),
-                    assets.amount_by_and_cents(2, 1250).expect("amount"),
-                ),
-                (
-                    fee.clone(),
-                    assets.amount_by_and_cents(2, 50).expect("amount"),
-                ),
+                (dest.clone(), usd.from_human("12.5").expect("amount")),
+                (fee.clone(), usd.from_human("0.5").expect("amount")),
             ],
         )
         .await
@@ -146,27 +111,27 @@ async fn balance_decreases_while_pending_spending_and_confirm() {
         .clone();
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
+        vec![usd.from_human("17").expect("amount"),],
         ledger.get_balance(&source).await.expect("balance")
     );
     assert!(ledger.get_balance(&dest).await.expect("balance").is_empty());
     assert!(ledger.get_balance(&fee).await.expect("balance").is_empty());
 
     ledger
-        .change_status(&id, Status::Settled, "ready".to_owned())
+        .change_status(&id, "settled".into(), "ready".to_owned())
         .await
         .expect("valid tx");
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
+        vec![usd.from_human("17").expect("amount"),],
         ledger.get_balance(&source).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 1250).expect("amount")],
+        vec![usd.from_human("12.5").expect("amount"),],
         ledger.get_balance(&dest).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 50).expect("amount")],
+        vec![usd.from_human("0.5").expect("amount"),],
         ledger.get_balance(&fee).await.expect("balance")
     );
 }
@@ -176,43 +141,25 @@ async fn balance_decreases_while_pending_spending_and_cancel() {
     let source = "account1".parse::<AccountId>().expect("account");
     let dest = "account2".parse::<AccountId>().expect("account");
     let fee = "fee".parse::<AccountId>().expect("account");
-    let (assets, ledger) = get_asset_manager_and_ledger().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;
+    let ledger = get_asset_manager_and_ledger().await;
+    let usd: Asset = "USD/2".parse().expect("asset");
+
+    deposit(&ledger, &source, usd.from_human("10").expect("amount")).await;
+    deposit(&ledger, &source, usd.from_human("20").expect("amount")).await;
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 3000).expect("amount")],
+        vec![usd.from_human("30").expect("amount"),],
         ledger.get_balance(&source).await.expect("balance")
     );
 
     let id = ledger
         .new_transaction(
             "Exchange one".to_owned(),
-            Status::Pending,
-            vec![(
-                source.clone(),
-                assets.amount_by_and_cents(2, 1300).expect("amount"),
-            )],
+            "pending".into(),
+            vec![(source.clone(), usd.from_human("13").expect("amount"))],
             vec![
-                (
-                    dest.clone(),
-                    assets.amount_by_and_cents(2, 1250).expect("amount"),
-                ),
-                (
-                    fee.clone(),
-                    assets.amount_by_and_cents(2, 50).expect("amount"),
-                ),
+                (dest.clone(), usd.from_human("12.5").expect("amount")),
+                (fee.clone(), usd.from_human("0.5").expect("amount")),
             ],
         )
         .await
@@ -221,19 +168,19 @@ async fn balance_decreases_while_pending_spending_and_cancel() {
         .clone();
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
+        vec![usd.from_human("17").expect("amount"),],
         ledger.get_balance(&source).await.expect("balance")
     );
     assert!(ledger.get_balance(&dest).await.expect("balance").is_empty());
     assert!(ledger.get_balance(&fee).await.expect("balance").is_empty());
 
     ledger
-        .change_status(&id, Status::Cancelled, "cancelled by test".to_owned())
+        .change_status(&id, "cancelled".into(), "cancelled by test".to_owned())
         .await
         .expect("valid tx");
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 3000).expect("amount")],
+        vec![usd.from_human("30").expect("amount"),],
         ledger.get_balance(&source).await.expect("balance")
     );
     assert!(ledger.get_balance(&dest).await.expect("balance").is_empty());
@@ -241,47 +188,30 @@ async fn balance_decreases_while_pending_spending_and_cancel() {
 }
 
 #[tokio::test]
-async fn balance_decreases_while_pending_spending_and_failed() {
+async fn balance_decreases_while_pending_spending_and_faileialance_decreases_while_pending_spending_and_failed(
+) {
     let source = "account1".parse::<AccountId>().expect("account");
     let dest = "account2".parse::<AccountId>().expect("account");
     let fee = "fee".parse::<AccountId>().expect("account");
-    let (assets, ledger) = get_asset_manager_and_ledger().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;
+    let ledger = get_asset_manager_and_ledger().await;
+    let usd: Asset = "USD/2".parse().expect("asset");
+
+    deposit(&ledger, &source, usd.from_human("10").expect("amount")).await;
+    deposit(&ledger, &source, usd.from_human("20").expect("amount")).await;
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 3000).expect("amount")],
+        vec![usd.from_human("30").expect("amount"),],
         ledger.get_balance(&source).await.expect("balance")
     );
 
     let tx = ledger
         .new_transaction(
             "Exchange one".to_owned(),
-            Status::Pending,
-            vec![(
-                source.clone(),
-                assets.amount_by_and_cents(2, 1300).expect("amount"),
-            )],
+            "pending".into(),
+            vec![(source.clone(), usd.from_human("13").expect("amount"))],
             vec![
-                (
-                    dest.clone(),
-                    assets.amount_by_and_cents(2, 1250).expect("amount"),
-                ),
-                (
-                    fee.clone(),
-                    assets.amount_by_and_cents(2, 50).expect("amount"),
-                ),
+                (dest.clone(), usd.from_human("12.5").expect("amount")),
+                (fee.clone(), usd.from_human("0.5").expect("amount")),
             ],
         )
         .await
@@ -290,47 +220,47 @@ async fn balance_decreases_while_pending_spending_and_failed() {
         .clone();
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
+        vec![usd.from_human("17").expect("amount"),],
         ledger.get_balance(&source).await.expect("balance")
     );
     assert!(ledger.get_balance(&dest).await.expect("balance").is_empty());
     assert!(ledger.get_balance(&fee).await.expect("balance").is_empty());
 
     ledger
-        .change_status(&tx, Status::Processing, "processing now".to_owned())
+        .change_status(&tx, "processing".into(), "processing now".to_owned())
         .await
         .expect("valid tx");
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
+        vec![usd.from_human("17").expect("amount"),],
         ledger.get_balance(&source).await.expect("balance")
     );
     assert!(ledger.get_balance(&dest).await.expect("balance").is_empty());
     assert!(ledger.get_balance(&fee).await.expect("balance").is_empty());
 
     assert_eq!(
-        "Transaction: Status transition from Processing to Cancelled is not allowed".to_owned(),
+        "Transaction: Error in status: Invalid transition from processing to cancelled".to_owned(),
         ledger
-            .change_status(&tx, Status::Cancelled, "cancelled by user".to_owned())
+            .change_status(&tx, "cancelled".into(), "cancelled by user".to_owned())
             .await
             .unwrap_err()
             .to_string()
     );
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
+        vec![usd.from_human("17").expect("amount"),],
         ledger.get_balance(&source).await.expect("balance")
     );
     assert!(ledger.get_balance(&dest).await.expect("balance").is_empty());
     assert!(ledger.get_balance(&fee).await.expect("balance").is_empty());
 
     ledger
-        .change_status(&tx, Status::Failed, "it has failed".to_owned())
+        .change_status(&tx, "failed".into(), "it has failed".to_owned())
         .await
         .expect("valid");
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 3000).expect("amount")],
+        vec![usd.from_human("30").expect("amount"),],
         ledger.get_balance(&source).await.expect("balance")
     );
     assert!(ledger.get_balance(&dest).await.expect("balance").is_empty());

utxo/src/tests/mod.rs

@@ -1,11 +1,11 @@
 use crate::{
-    asset_manager::AssetDefinition, storage::sqlite::SQLite, storage::Storage, AccountId, Amount,
-    AssetManager, Error, Ledger, Status, TransactionId,
+    storage::sqlite::SQLite, storage::Storage, AccountId, Amount, Error, Ledger, Status,
+    TransactionId,
 };
 use sqlx::sqlite::SqlitePoolOptions;
 
 #[allow(unused)]
-pub async fn get_file_asset_manager_and_ledger<'a>(name: &str) -> (AssetManager, Ledger<SQLite>) {
+pub async fn get_file_asset_manager_and_ledger<'a>(name: &str) -> Ledger<SQLite> {
     let pool = SqlitePoolOptions::new()
         .max_connections(1)
         .idle_timeout(None)
@@ -14,17 +14,12 @@ pub async fn get_file_asset_manager_and_ledger<'a>(name: &str) -> (AssetManager,
         .await
         .expect("pool");
 
-    let assets = AssetManager::new(vec![
-        AssetDefinition::new(1, "BTC", 8),
-        AssetDefinition::new(2, "USD", 4),
-    ]);
-
-    let db = SQLite::new(pool, assets.clone());
+    let db = SQLite::new(pool);
     db.setup().await.expect("setup");
-    (assets.clone(), Ledger::new(db, assets))
+    Ledger::new(db.into())
 }
 
-pub async fn get_asset_manager_and_ledger() -> (AssetManager, Ledger<SQLite>) {
+pub async fn get_asset_manager_and_ledger() -> Ledger<SQLite> {
     let pool = SqlitePoolOptions::new()
         .max_connections(1)
         .idle_timeout(None)
@@ -33,14 +28,9 @@ pub async fn get_asset_manager_and_ledger() -> (AssetManager, Ledger<SQLite>) {
         .await
         .expect("pool");
 
-    let assets = AssetManager::new(vec![
-        AssetDefinition::new(1, "BTC", 8),
-        AssetDefinition::new(2, "USD", 4),
-    ]);
-
-    let db = SQLite::new(pool, assets.clone());
+    let db = SQLite::new(pool);
     db.setup().await.expect("setup");
-    (assets.clone(), Ledger::new(db, assets))
+    Ledger::new(db.into())
 }
 
 pub async fn withdrawal(
@@ -61,7 +51,7 @@ where
     S: Storage + Send + Sync,
 {
     ledger
-        .deposit(account_id, amount, Status::Settled, "Test".to_owned())
+        .deposit(account_id, amount, "settled".into(), "Test".to_owned())
         .await
         .expect("valid tx")
         .id()

utxo/src/tests/negative_deposit.rs

@@ -1,30 +1,21 @@
 use super::{deposit, get_asset_manager_and_ledger};
-use crate::{AccountId, Status};
+use crate::{AccountId, Asset};
 
 #[tokio::test]
 async fn negative_deposit_prevent_spending() {
     let source = "account1".parse::<AccountId>().expect("account");
     let dest = "account2".parse::<AccountId>().expect("account");
     let fee = "fee".parse::<AccountId>().expect("account");
-    let (assets, ledger) = get_asset_manager_and_ledger().await;
+    let ledger = get_asset_manager_and_ledger().await;
+    let usd: Asset = "USD/2".parse().expect("asset");
 
     // Deposit some money
-    deposit(
-        &ledger,
-        &source,
-        assets.amount_by_and_cents(2, 5000).expect("amount"),
-    )
-    .await;
+    deposit(&ledger, &source, usd.from_human("50").expect("amount")).await;
     // Take money of source's account
-    deposit(
-        &ledger,
-        &source,
-        assets.amount_by_and_cents(2, -10000).expect("amount"),
-    )
-    .await;
+    deposit(&ledger, &source, usd.from_human("-100").expect("amount")).await;
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, -5000).expect("amount")],
+        vec![usd.from_human("-50").expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
 
@@ -34,20 +25,11 @@ async fn negative_deposit_prevent_spending() {
         ledger
             .new_transaction(
                 "Exchange one".to_owned(),
-                Status::Settled,
-                vec![(
-                    source.clone(),
-                    assets.amount_by_and_cents(2, 1000).expect("amount")
-                )],
+                "settled".into(),
+                vec![(source.clone(), usd.from_human("10").expect("amount"))],
                 vec![
-                    (
-                        dest.clone(),
-                        assets.amount_by_and_cents(2, 950).expect("amount")
-                    ),
-                    (
-                        fee.clone(),
-                        assets.amount_by_and_cents(2, 50).expect("amount")
-                    ),
+                    (dest.clone(), usd.from_human("9.5").expect("amount")),
+                    (fee.clone(), usd.from_human("0.5").expect("amount")),
                 ],
             )
             .await
@@ -61,25 +43,16 @@ async fn negative_deposit_prevent_spending_payback() {
     let source = "account1".parse::<AccountId>().expect("account");
     let dest = "account2".parse::<AccountId>().expect("account");
     let fee = "fee".parse::<AccountId>().expect("account");
-    let (assets, ledger) = get_asset_manager_and_ledger().await;
+    let ledger = get_asset_manager_and_ledger().await;
+    let usd: Asset = "USD/2".parse().expect("asset");
 
     // Deposit some money
-    deposit(
-        &ledger,
-        &source,
-        assets.amount_by_and_cents(2, 5000).expect("amount"),
-    )
-    .await;
+    deposit(&ledger, &source, usd.from_human("50").expect("amount")).await;
     // Take money of source's account
-    deposit(
-        &ledger,
-        &source,
-        assets.amount_by_and_cents(2, -10000).expect("amount"),
-    )
-    .await;
+    deposit(&ledger, &source, usd.from_human("-100").expect("amount")).await;
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, -5000).expect("amount")],
+        vec![usd.from_human("-50").expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
 
@@ -89,20 +62,11 @@ async fn negative_deposit_prevent_spending_payback() {
         ledger
             .new_transaction(
                 "Exchange one".to_owned(),
-                Status::Settled,
-                vec![(
-                    source.clone(),
-                    assets.amount_by_and_cents(2, 1000).expect("amount")
-                )],
+                "settled".into(),
+                vec![(source.clone(), usd.from_human("10").expect("amount"))],
                 vec![
-                    (
-                        dest.clone(),
-                        assets.amount_by_and_cents(2, 950).expect("amount")
-                    ),
-                    (
-                        fee.clone(),
-                        assets.amount_by_and_cents(2, 50).expect("amount")
-                    ),
+                    (dest.clone(), usd.from_human("9.5").expect("amount")),
+                    (fee.clone(), usd.from_human("0.5").expect("amount")),
                 ],
             )
             .await
@@ -111,45 +75,31 @@ async fn negative_deposit_prevent_spending_payback() {
     );
 
     // Payback the debt
-    deposit(
-        &ledger,
-        &source,
-        assets.amount_by_and_cents(2, 15000).expect("amount"),
-    )
-    .await;
+    deposit(&ledger, &source, usd.from_human("150").expect("amount")).await;
 
     ledger
         .new_transaction(
             "Exchange one".to_owned(),
-            Status::Settled,
-            vec![(
-                source.clone(),
-                assets.amount_by_and_cents(2, 1000).expect("amount"),
-            )],
+            "settled".into(),
+            vec![(source.clone(), usd.from_human("10").expect("amount"))],
             vec![
-                (
-                    dest.clone(),
-                    assets.amount_by_and_cents(2, 950).expect("amount"),
-                ),
-                (
-                    fee.clone(),
-                    assets.amount_by_and_cents(2, 50).expect("amount"),
-                ),
+                (dest.clone(), usd.from_human("9.5").expect("amount")),
+                (fee.clone(), usd.from_human("0.5").expect("amount")),
             ],
         )
         .await
         .expect("valid tx");
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 950).expect("amount")],
+        vec![usd.from_human("9.5").expect("amount")],
         ledger.get_balance(&dest).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 50).expect("amount")],
+        vec![usd.from_human("0.5").expect("amount")],
         ledger.get_balance(&fee).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 9000).expect("amount")],
+        vec![usd.from_human("90").expect("amount")],
         ledger.get_balance(&source).await.expect("balance")
     );
 }

utxo/src/tests/tx.rs

@@ -1,54 +1,41 @@
 use super::{deposit, get_asset_manager_and_ledger};
-use crate::{AccountId, Status, Type};
+use crate::{AccountId, Asset, Type};
 
 #[tokio::test]
 async fn multi_account_transfers() {
     let accounts = (0..100)
-        .into_iter()
         .map(|i| format!("account{}", i).parse::<AccountId>())
         .collect::<Result<Vec<AccountId>, _>>()
         .expect("valid");
     let target = "target".parse::<AccountId>().expect("target account");
-    let (assets, ledger) = get_asset_manager_and_ledger().await;
+    let ledger = get_asset_manager_and_ledger().await;
+    let usd: Asset = "USD/2".parse().expect("asset");
 
     for account in &accounts {
-        deposit(
-            &ledger,
-            &account,
-            assets.amount_by_and_cents(2, 100000).expect("amount"),
-        )
-        .await;
+        deposit(&ledger, account, usd.from_human("1000").expect("amount")).await;
     }
 
     let mut from = vec![];
-    for (p, account) in (&accounts).iter().enumerate() {
+    for (p, account) in accounts.iter().enumerate() {
         assert_eq!(
-            vec![assets.amount_by_and_cents(2, 100_000).expect("amount")],
-            ledger.get_balance(&account).await.expect("balance")
+            vec![usd.from_human("1000").expect("amount"),],
+            ledger.get_balance(account).await.expect("balance")
         );
-        from.push((
-            account.clone(),
-            assets
-                .amount_by_and_cents(2, 1000 * ((p + 1) as i128))
-                .expect("amount"),
-        ));
+        from.push((account.clone(), usd.new_amount(1000 * ((p + 1) as i128))));
     }
 
     ledger
         .new_transaction(
             "test tx".to_owned(),
-            Status::Settled,
+            "settled".into(),
             from,
-            vec![(
-                target.clone(),
-                assets.amount_by_and_cents(2, 5_050_000).expect("amount"),
-            )],
+            vec![(target.clone(), usd.from_human("50500").expect("amount"))],
         )
         .await
         .expect("valid tx");
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 5_050_000).expect("amount")],
+        vec![usd.from_human("50500").expect("amount"),],
         ledger.get_balance(&target).await.expect("balance")
     );
 

utxo/src/tests/withdrawal.rs

@@ -1,71 +1,53 @@
 use super::{deposit, get_asset_manager_and_ledger, withdrawal};
-use crate::{AccountId, Status};
+use crate::{AccountId, Asset};
 
 #[tokio::test]
 async fn deposit_transfer_and_withdrawal() {
     let source = "account1".parse::<AccountId>().expect("account");
     let dest = "account2".parse::<AccountId>().expect("account");
     let fee = "fee".parse::<AccountId>().expect("account");
-    let (assets, ledger) = get_asset_manager_and_ledger().await;
+    let ledger = get_asset_manager_and_ledger().await;
+    let usd: Asset = "USD/2".parse().expect("asset");
 
-    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;
+    deposit(&ledger, &source, usd.from_human("10").expect("amount")).await;
+    deposit(&ledger, &source, usd.from_human("20").expect("amount")).await;
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 3000).expect("amount")],
+        vec![usd.from_human("30").expect("amount"),],
         ledger.get_balance(&source).await.expect("balance")
     );
 
     ledger
         .new_transaction(
             "Exchange one".to_owned(),
-            Status::Settled,
-            vec![(
-                source.clone(),
-                assets.amount_by_and_cents(2, 1300).expect("amount"),
-            )],
+            "settled".into(),
+            vec![(source.clone(), usd.from_human("13").expect("amount"))],
             vec![
-                (
-                    dest.clone(),
-                    assets.amount_by_and_cents(2, 1250).expect("amount"),
-                ),
-                (
-                    fee.clone(),
-                    assets.amount_by_and_cents(2, 50).expect("amount"),
-                ),
+                (dest.clone(), usd.from_human("12.5").expect("amount")),
+                (fee.clone(), usd.from_human("0.5").expect("amount")),
             ],
         )
         .await
         .expect("valid tx");
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
+        vec![usd.from_human("17").expect("amount"),],
         ledger.get_balance(&source).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 1250).expect("amount")],
+        vec![usd.from_human("12.5").expect("amount"),],
         ledger.get_balance(&dest).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 50).expect("amount")],
+        vec![usd.from_human("0.5").expect("amount"),],
         ledger.get_balance(&fee).await.expect("balance")
     );
 
     assert!(withdrawal(
         &ledger,
         &source,
-        Status::Settled,
-        assets.amount_by_and_cents(2, 1700).expect("amount")
+        "settled".into(),
+        usd.from_human("17").expect("amount"),
     )
     .await
     .is_ok());
@@ -76,11 +58,11 @@ async fn deposit_transfer_and_withdrawal() {
         .expect("balance")
         .is_empty());
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 1250).expect("amount")],
+        vec![usd.from_human("12.5").expect("amount")],
         ledger.get_balance(&dest).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 50).expect("amount")],
+        vec![usd.from_human("0.5").expect("amount")],
         ledger.get_balance(&fee).await.expect("balance")
     );
 }
@@ -90,80 +72,62 @@ async fn fail_to_overwithdrawal() {
     let source = "account1".parse::<AccountId>().expect("account");
     let dest = "account2".parse::<AccountId>().expect("account");
     let fee = "fee".parse::<AccountId>().expect("account");
-    let (assets, ledger) = get_asset_manager_and_ledger().await;
+    let ledger = get_asset_manager_and_ledger().await;
+    let usd: Asset = "USD/2".parse().expect("asset");
 
-    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;
+    deposit(&ledger, &source, usd.from_human("10").expect("amount")).await;
+    deposit(&ledger, &source, usd.from_human("20").expect("amount")).await;
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 3000).expect("amount")],
+        vec![usd.from_human("30").expect("amount"),],
         ledger.get_balance(&source).await.expect("balance")
     );
 
     ledger
         .new_transaction(
             "Exchange one".to_owned(),
-            Status::Settled,
-            vec![(
-                source.clone(),
-                assets.amount_by_and_cents(2, 1300).expect("amount"),
-            )],
+            "settled".into(),
+            vec![(source.clone(), usd.from_human("13").expect("amount"))],
             vec![
-                (
-                    dest.clone(),
-                    assets.amount_by_and_cents(2, 1250).expect("amount"),
-                ),
-                (
-                    fee.clone(),
-                    assets.amount_by_and_cents(2, 50).expect("amount"),
-                ),
+                (dest.clone(), usd.from_human("12.5").expect("amount")),
+                (fee.clone(), usd.from_human("0.5").expect("amount")),
             ],
         )
         .await
         .expect("valid tx");
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
+        vec![usd.from_human("17").expect("amount"),],
         ledger.get_balance(&source).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 1250).expect("amount")],
+        vec![usd.from_human("12.5").expect("amount"),],
         ledger.get_balance(&dest).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 50).expect("amount")],
+        vec![usd.from_human("0.5").expect("amount"),],
         ledger.get_balance(&fee).await.expect("balance")
     );
 
     assert!(withdrawal(
         &ledger,
         &source,
-        Status::Settled,
-        assets.amount_by_and_cents(2, 170000).expect("amount")
+        "settled".into(),
+        usd.from_human("1700").expect("amount"),
     )
     .await
     .is_err());
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
+        vec![usd.from_human("17").expect("amount"),],
         ledger.get_balance(&source).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 1250).expect("amount")],
+        vec![usd.from_human("12.5").expect("amount"),],
         ledger.get_balance(&dest).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 50).expect("amount")],
+        vec![usd.from_human("0.5").expect("amount"),],
         ledger.get_balance(&fee).await.expect("balance")
     );
 }
@@ -173,66 +137,48 @@ async fn cancelled_withdrawal() {
     let source = "account1".parse::<AccountId>().expect("account");
     let dest = "account2".parse::<AccountId>().expect("account");
     let fee = "fee".parse::<AccountId>().expect("account");
-    let (assets, ledger) = get_asset_manager_and_ledger().await;
+    let ledger = get_asset_manager_and_ledger().await;
+    let usd: Asset = "USD/2".parse().expect("asset");
 
-    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;
+    deposit(&ledger, &source, usd.from_human("10").expect("amount")).await;
+    deposit(&ledger, &source, usd.from_human("20").expect("amount")).await;
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 3000).expect("amount")],
+        vec![usd.from_human("30").expect("amount"),],
         ledger.get_balance(&source).await.expect("balance")
     );
 
     ledger
         .new_transaction(
             "Exchange one".to_owned(),
-            Status::Settled,
-            vec![(
-                source.clone(),
-                assets.amount_by_and_cents(2, 1300).expect("amount"),
-            )],
+            "settled".into(),
+            vec![(source.clone(), usd.from_human("13").expect("amount"))],
             vec![
-                (
-                    dest.clone(),
-                    assets.amount_by_and_cents(2, 1250).expect("amount"),
-                ),
-                (
-                    fee.clone(),
-                    assets.amount_by_and_cents(2, 50).expect("amount"),
-                ),
+                (dest.clone(), usd.from_human("12.5").expect("amount")),
+                (fee.clone(), usd.from_human("0.5").expect("amount")),
             ],
         )
         .await
         .expect("valid tx");
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
+        vec![usd.from_human("17").expect("amount"),],
         ledger.get_balance(&source).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 1250).expect("amount")],
+        vec![usd.from_human("12.5").expect("amount"),],
         ledger.get_balance(&dest).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 50).expect("amount")],
+        vec![usd.from_human("0.5").expect("amount"),],
         ledger.get_balance(&fee).await.expect("balance")
     );
 
     let tx_id = withdrawal(
         &ledger,
         &source,
-        Status::Pending,
-        assets.amount_by_and_cents(2, 1700).expect("amount"),
+        "pending".into(),
+        usd.from_human("17").expect("amount"),
     )
     .await
     .expect("valid tx");
@@ -243,30 +189,30 @@ async fn cancelled_withdrawal() {
         .expect("balance")
         .is_empty());
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 1250).expect("amount")],
+        vec![usd.from_human("12.5").expect("amount"),],
         ledger.get_balance(&dest).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 50).expect("amount")],
+        vec![usd.from_human("0.5").expect("amount"),],
         ledger.get_balance(&fee).await.expect("balance")
     );
 
     ledger
-        .change_status(&tx_id, Status::Cancelled, "cancelled by test".to_owned())
+        .change_status(&tx_id, "cancelled".into(), "cancelled by test".to_owned())
         .await
         .expect("valid tx");
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
+        vec![usd.from_human("17").expect("amount"),],
         ledger.get_balance(&source).await.expect("balance")
     );
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 1250).expect("amount")],
+        vec![usd.from_human("12.5").expect("amount"),],
         ledger.get_balance(&dest).await.expect("balance")
     );
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, 50).expect("amount")],
+        vec![usd.from_human("0.5").expect("amount"),],
         ledger.get_balance(&fee).await.expect("balance")
     );
 }
@@ -274,30 +220,31 @@ async fn cancelled_withdrawal() {
 #[tokio::test]
 async fn negative_withdrawal() {
     let source = "account1".parse::<AccountId>().expect("account");
-    let (assets, ledger) = get_asset_manager_and_ledger().await;
+    let ledger = get_asset_manager_and_ledger().await;
+    let usd: Asset = "USD/2".parse().expect("asset");
 
     deposit(
         &ledger,
         &source,
-        assets.amount_by_and_cents(2, -1000).expect("amount"),
+        usd.from_human("-1000").expect("valid amount"),
     )
     .await;
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, -1000).expect("amount")],
+        vec![usd.from_human("-1000").expect("valid amount"),],
         ledger.get_balance(&source).await.expect("balance")
     );
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, -1000).expect("amount")],
+        vec![usd.from_human("-1000").expect("valid amount"),],
         ledger.get_balance(&source).await.expect("balance")
     );
 
     assert!(withdrawal(
         &ledger,
         &source,
-        Status::Settled,
-        assets.amount_by_and_cents(2, -1000).expect("amount"),
+        "settled".into(),
+        usd.from_human("-1000").expect("valid amount"),
     )
     .await
     .is_err());
@@ -305,8 +252,8 @@ async fn negative_withdrawal() {
     assert!(withdrawal(
         &ledger,
         &source,
-        Status::Settled,
-        assets.amount_by_and_cents(2, -1).expect("amount"),
+        "settled".into(),
+        usd.from_human("-1").expect("valid amount"),
     )
     .await
     .is_err());
@@ -314,8 +261,8 @@ async fn negative_withdrawal() {
     assert!(withdrawal(
         &ledger,
         &source,
-        Status::Settled,
-        assets.amount_by_and_cents(2, 0).expect("amount"),
+        "settled".into(),
+        usd.from_human("0").expect("valid amount"),
     )
     .await
     .is_err());
@@ -323,14 +270,14 @@ async fn negative_withdrawal() {
     assert!(withdrawal(
         &ledger,
         &source,
-        Status::Settled,
-        assets.amount_by_and_cents(2, 10).expect("amount"),
+        "settled".into(),
+        usd.from_human("10").expect("valid amount"),
     )
     .await
     .is_err());
 
     assert_eq!(
-        vec![assets.amount_by_and_cents(2, -1000).expect("amount")],
+        vec![usd.from_human("-1000").expect("valid amount"),],
         ledger.get_balance(&source).await.expect("balance")
     );
 }

utxo/src/transaction/changelog.rs

@@ -1,8 +0,0 @@
-use crate::Status;
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Deserialize, Serialize, Clone)]
-pub struct ChangelogEntry {
-    pub status: Status,
-    pub reason: String,
-}

utxo/src/transaction/error.rs

@@ -1,4 +1,4 @@
-use crate::{storage, Amount, Asset, Status, TransactionId};
+use crate::{status, storage, Amount, Asset, Status, TransactionId};
 use serde::Serialize;
 
 #[derive(thiserror::Error, Debug, Serialize)]
@@ -6,6 +6,9 @@ pub enum Error {
     #[error("Payment {0} is already spent")]
     SpentPayment(usize),
 
+    #[error("Error in status: {0}")]
+    Status(#[from] status::Error),
+
     #[error("Payment {0} is in the incorrect status {1}")]
     InvalidPaymentStatus(usize, Status),
 
@@ -32,10 +35,11 @@ pub enum Error {
 
     #[error("Internal error at serializing: {0}")]
     #[serde(serialize_with = "crate::serialize_error_to_string")]
-    Internal(#[from] Box<bincode::ErrorKind>),
+    Serde(#[from] Box<bincode::ErrorKind>),
 
-    #[error("Invalid changelog: {0}")]
-    Changelog(#[from] crate::changelog::Error),
+    #[error("No storage update when expecting")]
+    /// No update was performed when expecting one
+    NoUpdate,
 
     #[error("Invalid calculated id {0} (expected {1})")]
     InvalidTransactionId(TransactionId, TransactionId),

utxo/src/transaction/from_db.rs

@@ -1,18 +0,0 @@
-use super::{ChangelogEntry, Type};
-use crate::{changelog::Changelog, Payment, Status, TransactionId};
-use chrono::{DateTime, Utc};
-
-#[derive(Debug, Clone)]
-pub struct Transaction {
-    pub id: TransactionId,
-    pub spend: Vec<Payment>,
-    pub create: Vec<Payment>,
-    pub reference: String,
-    pub typ: Type,
-    pub status: Status,
-    pub last_change: Vec<u8>,
-    pub tags: Vec<String>,
-    pub changelog: Vec<Changelog<ChangelogEntry>>,
-    pub created_at: DateTime<Utc>,
-    pub updated_at: DateTime<Utc>,
-}

utxo/src/transaction/inner.rs

@@ -1,57 +1,41 @@
 use crate::{
     amount::AmountCents,
-    changelog::{sort_changes, Changelog},
-    payment::{self, SpentInfo},
-    storage::{Batch, Storage},
+    config::Config,
+    payment::PaymentTo,
+    storage::{self, Batch, Storage},
     transaction::*,
-    AccountId, Amount, Asset, Payment, PaymentId, Status, TransactionId,
+    AccountId, Amount, Asset, PaymentFrom, Status, TransactionId,
 };
 use chrono::{serde::ts_milliseconds, DateTime, Utc};
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use sha2::{Digest, Sha256};
-use std::{collections::HashMap, ops::Deref};
+use std::collections::HashMap;
 
-/// Transactions
-///
-/// Transactions are the core components of the ledger. The transactions are a
-/// list of unspent payments that are about to be spend, to create a new set of
-/// Payments, that can be spend in the future. This model is heavily inspired in
-/// Bitcoin's UTXO model. The terms in this context are payments, spend and
-/// create instead of unspent transactions, input and output.
+/// Transaction Inner
 ///
-/// This simple architecture allows to track accounts pretty efficiently,
-/// because all that matters are unspent payments owned by a given account.
-/// Every spent payment is stored for historical reasons but it is not relevant
-/// for any calculations regarding available funds.
+/// This is the transaction details, as described bellow, it is a Transaction but without the ID nor
+/// the revision ID.
 ///
-/// The transaction has a few rules, for instance the sum of spend Payments
-/// should be the same as create Payments, for each easy. There is no 'fee'
-/// concept, so any mismatch in any direction will error the constructor.
+/// This seperated struct is used to calculate the ID of the transaction, and to be able to
+/// serialize the transaction without the ID.
 ///
-/// Transactions are immutable after they are finalized, and the payments can
-/// only be re-usable if the transaction failed or was cancelled. Once the
-/// transaction settles the spent payments are forever spent. Any rollback
-/// should be a new transaction, initiated by a higher layer.
-///
-/// The spent payments are unavailable until the transaction is finalized,
-/// either as settled, cancelled or failed. A higher layer should split any
-/// available payment to be spend into a new transaction, and then finalize the
-/// transaction, and reserve only the exact amount to be spent, otherwise
-/// unrelated funds will be held unspendable until the transaction is finalized.
-#[derive(Debug, Clone, Serialize)]
-pub struct Transaction {
-    id: TransactionId,
-    #[serde(skip_serializing_if = "Vec::is_empty")]
-    spends: Vec<Payment>,
+/// 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)]
+pub struct TransactionInner {
+    /// A pointer to the first revision of the transaction.
+    first_revision: Option<TransactionId>,
+    /// Any previous transaction that this transaction is replacing.
+    previous: Option<TransactionId>,
+    /// 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,
-    #[serde(skip_serializing_if = "Vec::is_empty")]
-    creates: Vec<Payment>,
-    changelog: Vec<Changelog<ChangelogEntry>>,
     status: Status,
-    #[serde(skip_serializing_if = "Vec::is_empty")]
     tags: Vec<String>,
     #[serde(with = "ts_milliseconds")]
     created_at: DateTime<Utc>,
@@ -59,6 +43,144 @@ pub struct Transaction {
     updated_at: DateTime<Utc>,
 }
 
+impl TransactionInner {
+    pub fn calculate_id(&self) -> Result<TransactionId, Error> {
+        let mut hasher = Sha256::new();
+        let bytes = bincode::serialize(self)?;
+        hasher.update(bytes);
+        Ok(TransactionId::new(hasher.finalize().into()))
+    }
+
+    /// The transaction fingerprint is a hash of the properties that are not allowed to be updated
+    /// in a transaction.
+    pub fn transaction_fingerprint(&self) -> Result<TransactionId, Error> {
+        let mut hasher = Sha256::new();
+        hasher.update(&bincode::serialize(&self.spends)?);
+        hasher.update(&bincode::serialize(&self.creates)?);
+        hasher.update(&self.typ.to_string());
+        hasher.update(&self.reference);
+        hasher.update(&self.created_at.timestamp_millis().to_string());
+        Ok(TransactionId::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 {
+    /// The TransactionID is the RevisionID of the first revision of the transaction.
+    pub id: TransactionId,
+    /// Current Revision ID.
+    pub revision: TransactionId,
+    /// The transaction inner details
+    #[serde(flatten)]
+    inner: TransactionInner,
+}
+
+impl TryFrom<TransactionInner> for Transaction {
+    type Error = Error;
+
+    fn try_from(inner: TransactionInner) -> Result<Self, Self::Error> {
+        let id = inner.calculate_id()?;
+        Ok(Transaction {
+            id: inner.first_revision.clone().unwrap_or_else(|| id.clone()),
+            revision: id,
+            inner,
+        })
+    }
+}
+
 impl Transaction {
     /// Creates a new external deposit transaction
     ///
@@ -70,70 +192,47 @@ impl Transaction {
         status: Status,
         pay_to: Vec<(AccountId, Amount)>,
     ) -> Result<Transaction, Error> {
-        let created_at = Utc::now();
-        let id = Self::calculate_id(
-            &reference,
-            vec![],
-            pay_to
-                .iter()
-                .map(|t| (&t.0, &t.1))
-                .collect::<Vec<(&AccountId, &Amount)>>(),
-            created_at,
-        )?;
-        let create = pay_to
-            .into_iter()
-            .enumerate()
-            .map(|(position, (to, amount))| {
-                let id = crate::PaymentId {
-                    transaction: id.clone(),
-                    position,
-                };
-                let id_bytes = id.bytes().to_vec();
-                Payment {
-                    id,
-                    to,
-                    amount,
-                    spent: None,
-                    changelog: vec![Changelog::new(
-                        None,
-                        id_bytes,
-                        payment::ChangelogEntry {
-                            status: status.clone(),
-                            reason: reference.clone(),
-                            spent: None,
-                        },
-                    )],
-                    status: status.clone(),
-                }
-            })
-            .collect();
-
-        let changelog: Vec<Changelog<changelog::ChangelogEntry>> = vec![Changelog::new(
-            None,
-            id.deref().to_vec(),
-            ChangelogEntry {
-                status: status.clone(),
-                reason: reference.clone(),
-            },
-        )];
-
-        Ok(Self {
-            id,
+        TransactionInner {
+            first_revision: None,
+            changelog: "".to_owned(),
+            previous: None,
             spends: vec![],
-            creates: create,
+            creates: pay_to
+                .into_iter()
+                .map(|(to, amount)| PaymentTo { to, amount })
+                .collect(),
             reference,
             typ: Type::Deposit,
             tags: Vec::new(),
             status,
-            changelog,
-            created_at,
+            created_at: Utc::now(),
             updated_at: Utc::now(),
-        })
+        }
+        .try_into()
     }
 
-    /// Returns a mutable reference to the tags associated with this transaction
-    pub fn get_tags_mut(&mut self) -> &mut [String] {
-        &mut self.tags
+    /// 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
+            .inner
+            .creates
+            .iter()
+            .map(|x| x.to.clone())
+            .collect::<Vec<_>>();
+
+        accounts.extend(
+            self.inner
+                .spends
+                .iter()
+                .map(|x| x.from.clone())
+                .collect::<Vec<_>>(),
+        );
+
+        accounts.sort();
+        accounts.dedup();
+        accounts
     }
 
     /// Creates a new external withdrawal transaction
@@ -142,48 +241,27 @@ impl Transaction {
     pub fn new_external_withdrawal(
         reference: String,
         status: Status,
-        spend: Vec<Payment>,
+        spend: Vec<PaymentFrom>,
     ) -> Result<Transaction, Error> {
-        let created_at = Utc::now();
-        let id = Self::calculate_id(
-            &reference,
-            spend.iter().map(|t| &t.id).collect::<Vec<&PaymentId>>(),
-            vec![],
-            created_at,
-        )?;
-        let spend = spend
-            .into_iter()
-            .map(|mut payment| {
-                payment.spent = Some(SpentInfo {
-                    by: id.clone(),
-                    status: status.clone(),
-                });
-                payment.new_changelog(&reference);
-                payment
-            })
-            .collect();
-
-        let changelog: Vec<Changelog<changelog::ChangelogEntry>> = vec![Changelog::new(
-            None,
-            id.deref().to_vec(),
-            ChangelogEntry {
-                status: status.clone(),
-                reason: reference.clone(),
-            },
-        )];
-
-        Ok(Self {
-            id,
+        TransactionInner {
+            first_revision: None,
+            changelog: "".to_owned(),
+            previous: None,
             spends: spend,
             creates: vec![],
+            reference,
             typ: Type::Withdrawal,
             tags: Vec::new(),
-            reference,
             status,
-            changelog,
-            created_at,
+            created_at: Utc::now(),
             updated_at: Utc::now(),
-        })
+        }
+        .try_into()
+    }
+
+    /// Gets the inner transaction
+    pub fn inner(&self) -> &TransactionInner {
+        &self.inner
     }
 
     /// Creates a new transaction
@@ -191,254 +269,91 @@ impl Transaction {
         reference: String,
         status: Status,
         typ: Type,
-        spend: Vec<Payment>,
+        spends: Vec<PaymentFrom>,
         pay_to: Vec<(AccountId, Amount)>,
     ) -> Result<Transaction, Error> {
-        let created_at = Utc::now();
-        let id = Self::calculate_id(
-            &reference,
-            spend.iter().map(|t| &t.id).collect::<Vec<&PaymentId>>(),
-            pay_to
-                .iter()
-                .map(|t| (&t.0, &t.1))
-                .collect::<Vec<(&AccountId, &Amount)>>(),
-            created_at,
-        )?;
-
-        for (i, input) in spend.iter().enumerate() {
-            if !input.is_spendable_or_was_by(&id) {
-                return Err(Error::InvalidPaymentStatus(i, input.status.clone()));
-            }
-        }
-        let spend = spend
-            .into_iter()
-            .map(|mut payment| {
-                payment.spent = Some(SpentInfo {
-                    by: id.clone(),
-                    status: status.clone(),
-                });
-                payment.new_changelog(&reference);
-                payment
-            })
-            .collect();
-
+        // 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()
-            .enumerate()
-            .map(|(position, (to, amount))| {
-                let mut payment = Payment {
-                    id: crate::PaymentId {
-                        transaction: id.clone(),
-                        position,
-                    },
-                    to,
-                    amount,
-                    spent: None,
-                    changelog: vec![],
-                    status: status.clone(),
-                };
-                payment.new_changelog(&reference);
-                payment
-            })
+            .map(|(to, amount)| PaymentTo { to, amount })
             .collect();
 
-        let changelog: Vec<Changelog<changelog::ChangelogEntry>> = vec![Changelog::new(
-            None,
-            id.deref().to_vec(),
-            ChangelogEntry {
-                status: status.clone(),
-                reason: reference.clone(),
-            },
-        )];
-
-        Ok(Self {
-            id,
+        TransactionInner {
+            first_revision: None,
+            changelog: "".to_owned(),
+            previous: None,
+            spends,
+            creates: create,
             reference,
-            spends: spend,
             typ,
-            creates: create,
             tags: Vec::new(),
             status,
-            changelog,
-            created_at,
+            created_at: Utc::now(),
             updated_at: Utc::now(),
-        })
-    }
-
-    fn calculate_id(
-        reference: &str,
-        spend: Vec<&PaymentId>,
-        create: Vec<(&AccountId, &Amount)>,
-        created_at: DateTime<Utc>,
-    ) -> Result<TransactionId, Error> {
-        let mut hasher = Sha256::new();
-        let mut spend = spend;
-
-        spend.sort();
-
-        for id in spend.into_iter() {
-            hasher.update(&bincode::serialize(id)?);
         }
-        for (account, amount) in create.into_iter() {
-            hasher.update(&bincode::serialize(account)?);
-            hasher.update(&bincode::serialize(amount)?);
-        }
-        hasher.update(created_at.timestamp_millis().to_le_bytes());
-        hasher.update(reference);
-        Ok(TransactionId::new(hasher.finalize().into()))
+        .try_into()
     }
 
-    /// Settles the current transaction
+    /// Prepares a transaction ammend to update its status.
     ///
-    /// This is equivalent to changes the status to Settle and to persist
-    pub async fn settle<'a, S>(&mut self, storage: &'a S, reason: String) -> Result<(), Error>
+    /// 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,
     {
-        self.change_status(Status::Settled, reason)?;
-        self.persist::<S>(storage).await
-    }
-
-    /// Changes the status of a given transaction
-    #[inline]
-    pub fn change_status(&mut self, new_status: Status, reason: String) -> Result<(), Error> {
-        if self.status.can_transition_to(&new_status) {
-            for payment in self.spends.iter_mut() {
-                payment.spent = if new_status.is_rollback() {
-                    None
-                } else {
-                    Some(SpentInfo {
-                        by: self.id.clone(),
-                        status: new_status.clone(),
-                    })
-                };
-                payment.new_changelog(&reason);
-            }
-
-            for payment in self.creates.iter_mut() {
-                payment.status = new_status.clone();
-                payment.new_changelog(&reason);
-            }
-
-            let previous = self.changelog.last().map(|x| x.id()).transpose()?;
-            self.changelog.push(Changelog::new(
-                previous,
-                self.id.deref().to_vec(),
-                ChangelogEntry {
-                    status: new_status.clone(),
-                    reason,
-                },
-            ));
-            self.status = new_status;
-            Ok(())
-        } else {
-            Err(Error::StatusTransitionNotAllowed(
-                self.status.clone(),
-                new_status,
-            ))
-        }
-    }
-
-    #[inline]
-    /// Checks if the transaction attempts to spend any negative amount (which is no allowed)
-    fn check_no_negative_amounts_are_spent(
-        &self,
-        debit: &HashMap<Asset, i128>,
-    ) -> Result<(), Error> {
-        for (asset, amount) in debit.iter() {
-            if *amount <= 0 {
-                return Err(Error::InvalidAmount(
-                    asset.new_amount(*amount),
-                    asset.new_amount(*amount),
-                ));
-            }
+        config
+            .status
+            .is_valid_transition(&self.inner.status, &new_status)?;
+        let mut inner = self.inner;
+        inner.changelog = reason;
+        if inner.first_revision.is_none() {
+            inner.first_revision = Some(self.id);
         }
-
-        Ok(())
+        inner.updated_at = Utc::now();
+        inner.previous = Some(self.revision);
+        inner.status = new_status;
+        let mut x: Transaction = inner.try_into()?;
+        x.persist(config).await?;
+        Ok(x)
     }
 
     /// Validates the transaction before storing
     pub(crate) fn validate(&self) -> Result<(), Error> {
-        let calculated_id = Self::calculate_id(
-            &self.reference,
-            self.spends.iter().map(|p| &p.id).collect::<Vec<_>>(),
-            self.creates
-                .iter()
-                .map(|p| (&p.to, &p.amount))
-                .collect::<Vec<_>>(),
-            self.created_at,
-        )?;
-
-        if calculated_id != self.id {
-            return Err(Error::InvalidTransactionId(self.id.clone(), calculated_id));
-        }
-
-        let mut debit = HashMap::<Asset, AmountCents>::new();
-        let mut credit = HashMap::<Asset, AmountCents>::new();
-
-        for (i, input) in self.spends.iter().enumerate() {
-            if !input.is_spendable_or_was_by(&self.id) {
-                return Err(Error::SpentPayment(i));
-            }
-            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());
-            }
-        }
-
-        self.check_no_negative_amounts_are_spent(&debit)?;
-
-        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));
+        let calculated_revision_id = self.inner.calculate_id()?;
+
+        if self.revision != calculated_revision_id
+            || (self.inner.previous.is_none() && self.id != calculated_revision_id)
+        {
+            return Err(Error::InvalidTransactionId(
+                self.id.clone(),
+                calculated_revision_id,
+            ));
         }
 
-        Ok(())
+        self.inner.validate()
     }
 
     /// Returns the list of payments that were used to create this transaction
-    pub fn spends(&self) -> &[Payment] {
-        &self.spends
+    pub fn spends(&self) -> &[PaymentFrom] {
+        &self.inner.spends
     }
 
     /// Returns the list of payments that were created by this transaction
-    pub fn creates(&self) -> &[Payment] {
-        &self.creates
+    pub fn creates(&self) -> &[PaymentTo] {
+        &self.inner.creates
     }
 
     /// Returns the transaction ID
@@ -448,92 +363,121 @@ impl Transaction {
 
     /// Returns the transaction status
     pub fn status(&self) -> &Status {
-        &self.status
+        &self.inner.status
     }
 
     /// Returns the transaction type
-    pub fn typ(&self) -> &Type {
-        &self.typ
+    pub fn typ(&self) -> Type {
+        self.inner.typ
     }
 
     /// Returns the reference of this transaction
     pub fn reference(&self) -> &str {
-        &self.reference
-    }
-
-    /// Returns the last version of this transaction (the ID of the last entry from the changelog)
-    pub fn last_version(&self) -> Option<Vec<u8>> {
-        if let Some(Ok(x)) = self.changelog.last().map(|x| x.id()) {
-            Some(x)
-        } else {
-            None
-        }
+        &self.inner.reference
     }
 
     /// Returns the time when this transaction was created
     pub fn created_at(&self) -> DateTime<Utc> {
-        self.created_at
+        self.inner.created_at
     }
 
     /// Returns the time when this transaction was last updated
     pub fn updated_at(&self) -> DateTime<Utc> {
-        self.updated_at
+        self.inner.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, storage: &'a S) -> Result<(), Error>
+    /// 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,
     {
-        let mut batch = storage.begin().await?;
-        if let Some(status) = batch.get_payment_status(&self.id).await? {
-            if status.is_finalized() {
+        self.validate()?;
+
+        let mut batch = config.storage.begin().await?;
+
+        if let Some(previous_id) = &self.inner.previous {
+            // Make sure this update is updating the last revision and the status is not final
+            let current_transaction = batch.get_transaction(&self.id).await?;
+
+            if current_transaction.revision != *previous_id
+                || config.status.is_final(&current_transaction.inner.status)
+                || self.inner.transaction_fingerprint()?
+                    != current_transaction.inner.transaction_fingerprint()?
+            {
                 return Err(Error::TransactionUpdatesNotAllowed);
             }
-        }
-        self.validate()?;
-        self.updated_at = Utc::now();
-        batch.store_transaction(self).await?;
-        for payment in self.creates.iter() {
-            batch.store_new_payment(payment).await?;
+
+            // Updates all the spends to reflect the new status.
+            let (updated_created, updated_spent) = if config.status.is_reverted(&self.inner.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.inner.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.inner.creates.len()
+                || updated_spent != self.inner.spends.len()
+            {
+                return Err(Error::NoUpdate);
+            }
+        } else {
+            let spends = self
+                .inner
+                .spends
+                .iter()
+                .map(|x| x.id.clone())
+                .collect::<Vec<_>>();
+            let (spent_payment_status, creates_payment_status) =
+                if config.status.is_spendable(&self.inner.status) {
+                    (storage::Status::Spent, storage::Status::Spendable)
+                } else {
+                    (storage::Status::Locked, storage::Status::Locked)
+                };
             batch
-                .relate_account_to_transaction(self, &payment.to)
+                .spend_payments(&self.id, spends, spent_payment_status)
                 .await?;
-            batch.store_changelogs(&payment.changelog).await?;
-        }
-        for input in self.spends.iter() {
             batch
-                .update_payment(&input.id, &self.id, self.status.clone())
+                .create_payments(&self.id, &self.inner.creates, creates_payment_status)
                 .await?;
-            batch.relate_account_to_transaction(self, &input.to).await?;
-            batch.store_changelogs(&input.changelog).await?;
+
+            for account in self.accounts() {
+                batch
+                    .relate_account_to_transaction(&self.id, &account, self.typ())
+                    .await?;
+            }
         }
 
-        batch.tag_transaction(self, &self.tags).await?;
-        batch.store_changelogs(&self.changelog).await?;
-        batch.commit().await?;
-        Ok(())
-    }
-}
+        batch.store_transaction(self).await?;
 
-impl TryFrom<from_db::Transaction> for Transaction {
-    type Error = Error;
+        //batch.tag_transaction(self, &self.inner.tags).await?;
 
-    fn try_from(value: from_db::Transaction) -> Result<Self, Self::Error> {
-        let tx = Transaction {
-            id: value.id,
-            typ: value.typ,
-            spends: value.spend,
-            creates: value.create,
-            reference: value.reference,
-            tags: value.tags,
-            status: value.status,
-            changelog: sort_changes(value.changelog, value.last_change)?,
-            created_at: value.created_at,
-            updated_at: value.updated_at,
-        };
-        tx.validate()?;
-        Ok(tx)
+        batch.commit().await?;
+        Ok(())
     }
 }

utxo/src/transaction/mod.rs

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

utxo/src/transaction/typ.rs

@@ -31,6 +31,17 @@ impl Type {
     }
 }
 
+impl ToString for Type {
+    fn to_string(&self) -> String {
+        match self {
+            Type::Transaction => "transaction".to_string(),
+            Type::Deposit => "deposit".to_string(),
+            Type::Withdrawal => "withdrawal".to_string(),
+            Type::Exchange => "exchange".to_string(),
+        }
+    }
+}
+
 impl TryFrom<u32> for Type {
     type Error = Error;
     fn try_from(value: u32) -> Result<Self, Self::Error> {