ledger-prototype/utxo/src/tests/tx.rs

use super::{deposit, get_asset_manager_and_ledger};
use crate::{AccountId, Asset, Type};

#[tokio::test]
async fn multi_account_transfers() {
    let accounts = (0..100)
        .map(|i| format!("account{}", i).parse::<AccountId>())
        .collect::<Result<Vec<AccountId>, _>>()
        .expect("valid");
    let target = "target".parse::<AccountId>().expect("target account");
    let ledger = get_asset_manager_and_ledger().await;
    let usd: Asset = "USD/2".parse().expect("asset");

    for account in &accounts {
        deposit(&ledger, account, usd.from_human("1000").expect("amount")).await;
    }

    let mut from = vec![];
    for (p, account) in accounts.iter().enumerate() {
        assert_eq!(
            vec![usd.from_human("1000").expect("amount"),],
            ledger.get_balance(account).await.expect("balance")
        );
        from.push((account.clone(), usd.new_amount(1000 * ((p + 1) as i128))));
    }

    ledger
        .new_transaction(
            "test tx".to_owned(),
            "settled".into(),
            from,
            vec![(target.clone(), usd.from_human("50500").expect("amount"))],
        )
        .await
        .expect("valid tx");

    assert_eq!(
        vec![usd.from_human("50500").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 _ 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());
    }
}