ledger-prototype/utxo/src/ledger.rs

use crate::{
    amount::AmountCents, config::Config, status::StatusManager, storage::Storage,
    transaction::Type, AccountId, Amount, Error, PaymentFrom, PaymentId, RevId, Status, Tag,
    Transaction, TxId,
};
use std::{cmp::Ordering, collections::HashMap, sync::Arc};

/// The Verax ledger
#[derive(Debug)]
pub struct Ledger<S>
where
    S: Storage + Sync + Send,
{
    config: Arc<Config<S>>,
}

impl<S> Clone for Ledger<S>
where
    S: Storage + Sync + Send,
{
    fn clone(&self) -> Self {
        Self {
            config: self.config.clone(),
        }
    }
}

impl<S> Ledger<S>
where
    S: Storage + Sync + Send,
{
    /// Creates a new ledger instance
    pub fn new(config: Config<S>) -> Self {
        Self {
            config: Arc::new(config),
        }
    }

    /// 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
    /// accounts to debit from and accounts to credit to. A single transaction
    /// can use multiple accounts to debit and credit, instead of a single
    /// account.
    ///
    /// This function selects the unspent payments to be used in a transaction,
    /// in a descending order (making sure to include any negative deposit).
    ///
    /// This function returns a vector of payments to be used as inputs and
    /// optionally a dependent transaction to be executed first. This
    /// transaction is an internal transaction and it settles immediately. It is
    /// used to split an existing payment into two payments, one to be used as
    /// input and the other to be used as change. This is done to avoid locking
    /// any change amount until the main transaction settles.
    async fn select_payments_from_accounts(
        &self,
        payments: Vec<(AccountId, Amount)>,
    ) -> Result<(Option<Transaction>, Vec<PaymentFrom>), Error> {
        let mut to_spend = HashMap::<_, AmountCents>::new();

        for (account_id, amount) in payments.into_iter() {
            let id = (account_id, amount.asset().clone());
            if let Some(value) = to_spend.get_mut(&id) {
                *value = value
                    .checked_add(amount.cents())
                    .ok_or(Error::Overflow("cents".to_owned()))?;
            } else {
                to_spend.insert(id, amount.cents());
            }
        }

        let mut change_input = vec![];
        let mut change_output = 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, to_spend_cents)
                .await?;
            for payment in iterator.into_iter() {
                let cents = payment.amount.cents();
                to_spend_cents = to_spend_cents
                    .checked_sub(cents)
                    .ok_or(Error::Underflow("cents".to_owned()))?;
                payments.push(payment);
                match to_spend_cents.cmp(&0) {
                    Ordering::Equal => {
                        // No change amount, we are done with this input
                        break;
                    }
                    Ordering::Less => {
                        // There is a change amount, we need to split the last
                        // input into two payment_ids into the same accounts in
                        // a transaction that will settle immediately, otherwise
                        // the change amount will be unspendable until this
                        // transaction settles. By doing so the current
                        // operation will have no change and it can safely take
                        // its time to settle without making any change amount
                        // unspendable.
                        let to_spend_cents = to_spend_cents.abs();
                        let input = payments
                            .pop()
                            .ok_or(Error::InsufficientBalance(account.clone(), asset.clone()))?;

                        change_input.push(input);
                        change_output.push((
                            account.clone(),
                            asset.new_amount(
                                cents
                                    .checked_sub(to_spend_cents)
                                    .ok_or(Error::Underflow("change cents".to_owned()))?,
                            ),
                        ));
                        change_output.push((account.clone(), asset.new_amount(to_spend_cents)));

                        // Go to the next payment
                        break;
                    }
                    _ => {
                        // We need more funds, continue to the selecting the
                        // available payment if any
                    }
                }
            }

            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.clone()));
            }
        }

        let exchange_tx = if change_input.is_empty() {
            None
        } else {
            let total =
                u16::try_from(change_input.len()).map_err(|e| Error::Overflow(e.to_string()))?;
            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.
                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
                let index = i
                    .checked_mul(2)
                    .ok_or(Error::Overflow("index overflow".to_owned()))?;
                let uindex: usize = index.into();
                payments.push(PaymentFrom {
                    id: PaymentId {
                        transaction: split_input.id.clone(),
                        position: index,
                    },
                    from: creates[uindex].to.clone(),
                    amount: creates[uindex].amount.clone(),
                });
            }
            Some(split_input)
        };

        Ok((exchange_tx, payments))
    }

    /// Creates a new transaction and returns it.
    ///
    /// The input is pretty simple, take this amounts from these given accounts
    /// and send them to these accounts (and amounts). The job of this function
    /// is to figure it out how to do it. This function will make sure that each
    /// account has enough balance, selecting the unspent payments from each
    /// account that will be spent. It will also return a list of transactions
    /// that will be used to return the change to the accounts, these accounts
    /// can be settled immediately so no other funds required to perform the
    /// transaction are locked.
    ///
    /// This functions performs read only operations on top of the storage layer
    /// and it will guarantee execution (meaning that it will not lock any
    /// funds, so these transactions may fail if any selected payment is spent
    /// between the time the transaction is created and executed).
    ///
    /// A NewTransaction struct is returned, the change_transactions should be
    /// executed and set as settled before the transaction is executed,
    /// otherwise it will fail. A failure in any execution will render the
    /// entire operation as failed but no funds will be locked.
    pub async fn new_transaction(
        &self,
        reference: String,
        status: Status,
        from: Vec<(AccountId, Amount)>,
        to: Vec<(AccountId, Amount)>,
    ) -> 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.config).await?;
        }
        let mut transaction =
            Transaction::new(reference, status, Type::Transaction, payments, to).await?;
        transaction.persist(&self.config).await?;
        Ok(transaction)
    }

    /// Return the balances from a given account
    ///
    /// The balance is a vector of Amounts, one for each asset. The balance will
    /// return only spendable amounts, meaning that any amount that is locked in
    /// a transaction will not be returned.
    ///
    /// TODO: Return locked funds as well.
    pub async fn get_balance(&self, account: &AccountId) -> Result<Vec<Amount>, Error> {
        Ok(self.config.storage.get_balance(account).await?)
    }

    /// Creates an external deposit
    ///
    /// Although a deposit can have multiple output payments, to different
    /// accounts and amounts, to keep the upstream API simple, this function
    /// only accepts a single account and amount to credit
    pub async fn deposit(
        &self,
        account: &AccountId,
        amount: Amount,
        status: Status,
        reference: String,
    ) -> Result<Transaction, Error> {
        let mut transaction =
            Transaction::new_external_deposit(reference, status, vec![(account.clone(), amount)])?;
        transaction.persist(&self.config).await?;
        Ok(transaction)
    }

    /// Creates a new withdrawal transaction and returns it.
    ///
    /// Although a transaction supports multiple inputs to be burned, from
    /// different accounts, to keep things simple, this function only supports a
    /// single input (single account and single amount). This is because the
    /// natural behaviour is to have withdrawals from a single account.
    pub async fn withdrawal(
        &self,
        account: &AccountId,
        amount: Amount,
        status: Status,
        reference: String,
    ) -> Result<Transaction, Error> {
        let (change_transactions, payments) = self
            .select_payments_from_accounts(vec![(account.clone(), amount)])
            .await?;
        for mut change_tx in change_transactions.into_iter() {
            change_tx.persist(&self.config).await?;
        }
        let mut transaction = Transaction::new_external_withdrawal(reference, status, payments)?;
        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<PaymentFrom, Error> {
        todo!()
    }

    /// Returns the transaction object by a given revision id
    pub async fn get_transaction_by_revision(
        &self,
        revision_id: &RevId,
    ) -> Result<Transaction, Error> {
        Ok(self
            .config
            .storage
            .get_transaction(revision_id.into())
            .await?)
    }

    /// Returns the transaction object by a given transaction id
    pub async fn get_transaction(&self, transaction_id: &TxId) -> Result<Transaction, Error> {
        Ok(self
            .config
            .storage
            .get_transaction(transaction_id.clone().into())
            .await?)
    }

    /// Returns all transactions from a given account. It can be optionally be
    /// sorted by transaction type. The transactions are sorted from newest to
    /// oldest.
    pub async fn get_transactions(
        &self,
        account_id: &AccountId,
        types: Vec<Type>,
    ) -> Result<Vec<Transaction>, Error> {
        let types = if types.is_empty() {
            vec![Type::Transaction, Type::Deposit, Type::Withdrawal]
        } else {
            types
        };
        Ok(self
            .config
            .storage
            .get_transactions(account_id, &types, &[])
            .await?)
    }

    /// Returns the status manager
    pub fn get_status_manager(&self) -> &StatusManager {
        &self.config.status
    }

    /// Updates a transaction and updates their tags to this given set
    pub async fn set_tags(
        &self,
        transaction_id: &TxId,
        tags: Vec<Tag>,
        reason: String,
    ) -> Result<Transaction, Error> {
        Ok(self
            .config
            .storage
            .get_transaction(transaction_id.into())
            .await?
            .set_tags(&self.config, tags, reason)
            .await?)
    }

    /// Attempts to change the status of a given transaction id. On success the
    /// new transaction object is returned, otherwise an error is returned.
    pub async fn change_status(
        &self,
        revision_id: &RevId,
        new_status: Status,
        reason: String,
    ) -> Result<Transaction, Error> {
        Ok(self
            .config
            .storage
            .get_transaction(revision_id.into())
            .await?
            .change_status(&self.config, new_status, reason)
            .await?)
    }
}