Minor improvements

TODO.md

@@ -1,4 +1,5 @@
-- [ ] Optimize `select_inputs_from_accounts` to return a single change operation instead of a vector
+- [x] Optimize `select_inputs_from_accounts` to return a single change operation instead of a vector
+- [ ] Write cache layer on top of the storage layer, specially if accounts are settled
 - [ ] Improve read performance with SQLite
 - [ ] Add a locking mechanism, to either a start a tx per account, or use the storage engine as a lock mechanism (to lock the utxos)
 - [ ] Add ability to query accounts in a point in time

src/main.rs

@@ -106,6 +106,10 @@ struct Item {
 #[derive(Serialize)]
 struct AccountResponse {
     amount: String,
+    #[serde(
+        serialize_with = "verax::serialize_arc_str",
+        deserialize_with = "verax::deserialize_arc_str"
+    )]
     asset: Arc<str>,
 }
 

utxo/src/amount.rs

@@ -40,7 +40,7 @@ impl Serialize for Amount {
         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)?;
+        s.serialize_entry("asset", self.asset.name.to_string().as_str())?;
         s.end()
     }
 }

utxo/src/asset.rs

@@ -16,6 +16,10 @@ pub type AssetId = u32;
 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

utxo/src/asset_manager.rs

@@ -23,6 +23,10 @@ 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>,
 }
 

utxo/src/changelog.rs

@@ -12,7 +12,7 @@ pub enum Error {
     UnexpectedChanges(Vec<Vec<u8>>),
 
     #[error("Bincode: {0}")]
-    #[serde(serialize_with = "crate::error::serialize_to_string")]
+    #[serde(serialize_with = "crate::serialize_error_to_string")]
     Bincode(#[from] bincode::Error),
 }
 

utxo/src/error.rs

@@ -1,5 +1,5 @@
 use crate::{amount, asset::AssetId, storage, transaction, AccountId};
-use serde::{Serialize, Serializer};
+use serde::Serialize;
 use std::fmt::Display;
 
 /// The errors that can happen in the Verax crate
@@ -29,11 +29,3 @@ pub enum Error {
     #[error("Invalid amount: {0}")]
     InvalidAmount(#[from] amount::Error),
 }
-
-pub fn serialize_to_string<S, T>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
-where
-    S: Serializer,
-    T: ToString + Display,
-{
-    serializer.serialize_str(&value.to_string())
-}

utxo/src/lib.rs

@@ -28,6 +28,7 @@ mod error;
 mod id;
 mod ledger;
 mod payment;
+mod serde;
 #[cfg(any(feature = "sqlite", test))]
 pub mod sqlite;
 mod status;
@@ -46,6 +47,7 @@ pub use self::{
     id::*,
     ledger::Ledger,
     payment::{Payment, PaymentId},
+    serde::*,
     status::Status,
     transaction::{Transaction, Type},
 };

utxo/src/serde.rs

@@ -0,0 +1,30 @@
+use serde::{Serialize, Serializer};
+use std::{fmt::Display, sync::Arc};
+
+pub(crate) fn serialize_error_to_string<S, T>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+    T: ToString + Display,
+{
+    serializer.serialize_str(&value.to_string())
+}
+
+/// Serialize an Arc<str> as a string
+pub fn serialize_arc_str<S>(value: &Arc<str>, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    // Convert the Arc<str> to a String for serialization
+    let value_str: String = value.to_string();
+    serializer.serialize_str(&value_str)
+}
+
+/// Deserialize a string as an Arc<str>
+pub fn deserialize_arc_str<'de, D>(deserializer: D) -> Result<Arc<str>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    // Deserialize as a String and then convert it back to an Arc<str>
+    let value_str: String = serde::Deserialize::deserialize(deserializer)?;
+    Ok(Arc::from(value_str))
+}

utxo/src/tests/tx.rs

@@ -0,0 +1,70 @@
+use super::{deposit, get_instance, get_persistance_instance};
+use crate::{AccountId, Status, 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_instance().await;
+
+    for account in &accounts {
+        deposit(
+            &ledger,
+            &account,
+            assets.amount_by_and_cents(2, 100000).expect("amount"),
+        )
+        .await;
+    }
+
+    let mut from = vec![];
+    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")
+        );
+        from.push((
+            account.clone(),
+            assets
+                .amount_by_and_cents(2, 1000 * ((p + 1) as i128))
+                .expect("amount"),
+        ));
+    }
+
+    ledger
+        .new_transaction(
+            "test tx".to_owned(),
+            Status::Settled,
+            from,
+            vec![(
+                target.clone(),
+                assets.amount_by_and_cents(2, 5_050_000).expect("amount"),
+            )],
+        )
+        .await
+        .expect("valid tx");
+
+    assert_eq!(
+        vec![assets.amount_by_and_cents(2, 5_050_000).expect("amount")],
+        ledger.get_balance(&target).await.expect("balance")
+    );
+
+    let exchange_id = ledger
+        .get_transactions(&accounts[0], vec![Type::Exchange])
+        .await
+        .expect("valid")[0]
+        .id()
+        .clone();
+
+    for account in &accounts {
+        let txs = ledger
+            .get_transactions(&accounts[0], vec![Type::Exchange])
+            .await
+            .expect("valid");
+        assert_eq!(1, txs.len());
+        assert_eq!(exchange_id, *txs[0].id());
+    }
+}

utxo/src/transaction/error.rs

@@ -31,7 +31,7 @@ pub enum Error {
     Storage(#[from] storage::Error),
 
     #[error("Internal error at serializing: {0}")]
-    #[serde(serialize_with = "crate::error::serialize_to_string")]
+    #[serde(serialize_with = "crate::serialize_error_to_string")]
     Internal(#[from] Box<bincode::ErrorKind>),
 
     #[error("Invalid changelog: {0}")]