Improved negative balance

utxo/src/error.rs

@@ -1,4 +1,4 @@
-use crate::{amount, asset::Asset, status, storage, token, transaction, AccountId};
+use crate::{amount, asset::Asset, status, storage, token, transaction, AccountId, Amount};
 use serde::Serialize;
 
 /// The errors that can happen in the Verax crate
@@ -51,4 +51,8 @@ pub enum Error {
     /// Valid update token is required
     #[error("Valid update token is required")]
     ValidUpdateTokenRequired,
+
+    /// Account has negative balance
+    #[error("Account {0} has negative balance. Withdrawal is not allowed.")]
+    NegativeBalance(AccountId, Vec<Amount>),
 }

utxo/src/ledger.rs

@@ -480,6 +480,26 @@ where
         reference: String,
         replay_protection: Option<ReplayProtection>,
     ) -> Result<Transaction, Error> {
+        let has_negative_balance = self
+            .get_balance(account)
+            .await?
+            .into_iter()
+            .filter_map(|amount| {
+                if amount.cents() < 0 {
+                    Some(amount)
+                } else {
+                    None
+                }
+            })
+            .collect::<Vec<_>>();
+
+        if !has_negative_balance.is_empty() {
+            return Err(Error::NegativeBalance(
+                account.clone(),
+                has_negative_balance,
+            ));
+        }
+
         let (change_transactions, payments) = self
             .select_payments_from_accounts(vec![(account.clone(), amount)])
             .await?;

utxo/tests/ledger.rs

@@ -86,6 +86,31 @@ fn spend(world: &mut LedgerWorld, amount: String, asset: String, account: String
         .push((account.parse().expect("valid account"), amount));
 }
 
+#[then(expr = "withdraw from {word} {word} {word}")]
+async fn withdraw(world: &mut LedgerWorld, account: String, amount: String, asset: String) {
+    let asset = asset.parse::<Asset>().expect("valid asset");
+    let amount = asset.from_human(&amount).expect("valid amount");
+    let account = account.parse().expect("valid account");
+
+    world.variables.insert(
+        "latest".to_owned(),
+        world
+            .ledger
+            .withdrawal(&account, amount, "settled".into(), "test".to_owned(), None)
+            .await
+            .map(|x| x.revision_id)
+            .into(),
+    );
+}
+
+#[then("it fails")]
+async fn it_fails(world: &mut LedgerWorld) {
+    match world.variables.get("latest").expect("latest") {
+        Variable::RevIdResult(Err(_)) => {}
+        latest => panic!("expected error found: {:?}", latest),
+    }
+}
+
 #[given(expr = "receive {word} {word} in {word}")]
 fn receive(world: &mut LedgerWorld, amount: String, asset: String, account: String) {
     let asset = asset.parse::<Asset>().expect("valid asset");
@@ -98,20 +123,6 @@ fn receive(world: &mut LedgerWorld, amount: String, asset: String, account: Stri
         .push((account.parse().expect("valid account"), amount));
 }
 
-#[when(expr = "commit transaction {word} it fails")]
-async fn commit_transaction_and_expect_to_fail(world: &mut LedgerWorld, status: String) {
-    let status = status.parse::<verax::Status>().expect("valid status");
-
-    let spend = world.spend.take().expect("has spend");
-    let receive = world.receive.take().expect("has receive");
-
-    assert!(world
-        .ledger
-        .new_transaction("Transaction".to_owned(), status, spend, receive, None)
-        .await
-        .is_err());
-}
-
 #[when(expr = "commit transaction {word} as {word}")]
 async fn commit_transaction(world: &mut LedgerWorld, name: String, status: String) {
     let status = status.parse::<verax::Status>().expect("valid status");

utxo/tests/negative_balance.feature

@@ -18,5 +18,5 @@ Feature: Transactions with negative balance
     And a settled deposit @tx3 of 1.1 BTC/8 for @account1
     Then @account1 has balance of -1000 USD/2
     Then @account1 has balance of 1.1 BTC/8
-    Then withdraw 0.5 BTC/8
+    Then withdraw from @account1 0.5 BTC/8
     Then it fails