|
|
@@ -0,0 +1,311 @@
|
|
|
+use crate::{
|
|
|
+ amount::AmountCents, transaction::*, AccountId, Amount, Asset, Batch, Payment, PaymentId,
|
|
|
+ Status, Storage, TransactionId,
|
|
|
+};
|
|
|
+use sha2::{Digest, Sha256};
|
|
|
+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.
|
|
|
+///
|
|
|
+/// 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.
|
|
|
+///
|
|
|
+/// 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.
|
|
|
+///
|
|
|
+/// 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 unspentable until the transaction is finalized.
|
|
|
+#[derive(Debug, Clone)]
|
|
|
+pub struct Transaction {
|
|
|
+ id: TransactionId,
|
|
|
+ spend: Vec<Payment>,
|
|
|
+ #[allow(dead_code)]
|
|
|
+ reference: String,
|
|
|
+ create: Vec<Payment>,
|
|
|
+ status: Status,
|
|
|
+ is_external_deposit: bool,
|
|
|
+}
|
|
|
+
|
|
|
+impl Transaction {
|
|
|
+ pub fn new_external_deposit(
|
|
|
+ reference: String,
|
|
|
+ status: Status,
|
|
|
+ pay_to: Vec<(AccountId, Amount)>,
|
|
|
+ ) -> Result<Transaction, Error> {
|
|
|
+ let id = Self::calculate_hash(
|
|
|
+ vec![],
|
|
|
+ pay_to
|
|
|
+ .iter()
|
|
|
+ .map(|t| (&t.0, &t.1))
|
|
|
+ .collect::<Vec<(&AccountId, &Amount)>>(),
|
|
|
+ )?;
|
|
|
+ let create = pay_to
|
|
|
+ .into_iter()
|
|
|
+ .enumerate()
|
|
|
+ .map(|(position, (to, amount))| Payment {
|
|
|
+ id: crate::PaymentId {
|
|
|
+ transaction: id.clone(),
|
|
|
+ position,
|
|
|
+ },
|
|
|
+ to,
|
|
|
+ amount,
|
|
|
+ spent_by: None,
|
|
|
+ status: status.clone(),
|
|
|
+ })
|
|
|
+ .collect();
|
|
|
+
|
|
|
+ Ok(Self {
|
|
|
+ id,
|
|
|
+ spend: vec![],
|
|
|
+ create,
|
|
|
+ reference,
|
|
|
+ is_external_deposit: true,
|
|
|
+ status,
|
|
|
+ })
|
|
|
+ }
|
|
|
+
|
|
|
+ pub async fn new(
|
|
|
+ reference: String,
|
|
|
+ status: Status,
|
|
|
+ spend: Vec<Payment>,
|
|
|
+ pay_to: Vec<(AccountId, Amount)>,
|
|
|
+ ) -> Result<Transaction, Error> {
|
|
|
+ let id = Self::calculate_hash(
|
|
|
+ spend.iter().map(|t| &t.id).collect::<Vec<&PaymentId>>(),
|
|
|
+ pay_to
|
|
|
+ .iter()
|
|
|
+ .map(|t| (&t.0, &t.1))
|
|
|
+ .collect::<Vec<(&AccountId, &Amount)>>(),
|
|
|
+ )?;
|
|
|
+
|
|
|
+ for (i, input) in spend.iter().enumerate() {
|
|
|
+ if input.spent_by.is_some() && input.spent_by.as_ref() != Some(&id) {
|
|
|
+ return Err(Error::SpentPayment(i));
|
|
|
+ }
|
|
|
+ if input.spent_by.is_none() && input.status != Status::Settled {
|
|
|
+ return Err(Error::InvalidPaymentStatus(i, input.status.clone()));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ let spend = spend
|
|
|
+ .into_iter()
|
|
|
+ .map(|mut input| {
|
|
|
+ input.spent_by = Some(id.clone());
|
|
|
+ input
|
|
|
+ })
|
|
|
+ .collect();
|
|
|
+
|
|
|
+ let create = pay_to
|
|
|
+ .into_iter()
|
|
|
+ .enumerate()
|
|
|
+ .map(|(position, (to, amount))| Payment {
|
|
|
+ id: crate::PaymentId {
|
|
|
+ transaction: id.clone(),
|
|
|
+ position,
|
|
|
+ },
|
|
|
+ to,
|
|
|
+ amount,
|
|
|
+ spent_by: None,
|
|
|
+ status: status.clone(),
|
|
|
+ })
|
|
|
+ .collect();
|
|
|
+
|
|
|
+ Ok(Self {
|
|
|
+ id,
|
|
|
+ reference,
|
|
|
+ spend,
|
|
|
+ create,
|
|
|
+ is_external_deposit: false,
|
|
|
+ status,
|
|
|
+ })
|
|
|
+ }
|
|
|
+
|
|
|
+ fn calculate_hash(
|
|
|
+ spend: Vec<&PaymentId>,
|
|
|
+ create: Vec<(&AccountId, &Amount)>,
|
|
|
+ ) -> Result<TransactionId, Error> {
|
|
|
+ let mut hasher = Sha256::new();
|
|
|
+ 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)?);
|
|
|
+ }
|
|
|
+ Ok(TransactionId::new(hasher.finalize().into()))
|
|
|
+ }
|
|
|
+
|
|
|
+ pub async fn settle<'a, B, S>(&mut self, storage: &'a S) -> Result<(), Error>
|
|
|
+ where
|
|
|
+ B: Batch<'a>,
|
|
|
+ S: Storage<'a, B> + Sync + Send,
|
|
|
+ {
|
|
|
+ self.change_status(Status::Settled)?;
|
|
|
+ self.persist::<B, S>(storage).await
|
|
|
+ }
|
|
|
+
|
|
|
+ #[inline]
|
|
|
+ pub fn change_status(&mut self, new_status: Status) -> Result<(), Error> {
|
|
|
+ if self.status.can_transition_to(&new_status) {
|
|
|
+ self.spend.iter_mut().for_each(|payment| {
|
|
|
+ payment.status = new_status.clone();
|
|
|
+ if new_status.is_rollback() {
|
|
|
+ payment.spent_by = None;
|
|
|
+ }
|
|
|
+ });
|
|
|
+ self.create.iter_mut().for_each(|payment| {
|
|
|
+ payment.status = new_status.clone();
|
|
|
+ });
|
|
|
+ self.status = new_status;
|
|
|
+ Ok(())
|
|
|
+ } else {
|
|
|
+ Err(Error::StatusTransitionNotAllowed(
|
|
|
+ self.status.clone(),
|
|
|
+ new_status,
|
|
|
+ ))
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ pub(crate) fn validate(&self) -> Result<(), Error> {
|
|
|
+ if self.is_external_deposit {
|
|
|
+ return Ok(());
|
|
|
+ }
|
|
|
+
|
|
|
+ let calculated_id = Self::calculate_hash(
|
|
|
+ self.spend.iter().map(|p| &p.id).collect::<Vec<_>>(),
|
|
|
+ self.create
|
|
|
+ .iter()
|
|
|
+ .map(|p| (&p.to, &p.amount))
|
|
|
+ .collect::<Vec<_>>(),
|
|
|
+ )?;
|
|
|
+
|
|
|
+ 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.spend.iter().enumerate() {
|
|
|
+ if input.spent_by.is_some() && input.spent_by.as_ref() != Some(&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(), input.amount.cents());
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ for (i, output) in self.create.iter().enumerate() {
|
|
|
+ if output.spent_by.is_some() {
|
|
|
+ return Err(Error::SpentPayment(i));
|
|
|
+ }
|
|
|
+ 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(), 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, debit_amount, credit_amount));
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ return Err(Error::MissingSpendingAsset(asset));
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if let Some((asset, _)) = debit.into_iter().next() {
|
|
|
+ return Err(Error::MissingPaymentAsset(asset));
|
|
|
+ }
|
|
|
+
|
|
|
+ Ok(())
|
|
|
+ }
|
|
|
+
|
|
|
+ pub fn spent(&self) -> &[Payment] {
|
|
|
+ &self.spend
|
|
|
+ }
|
|
|
+
|
|
|
+ pub fn created(&self) -> &[Payment] {
|
|
|
+ &self.create
|
|
|
+ }
|
|
|
+
|
|
|
+ pub fn id(&self) -> &TransactionId {
|
|
|
+ &self.id
|
|
|
+ }
|
|
|
+
|
|
|
+ pub fn status(&self) -> &Status {
|
|
|
+ &self.status
|
|
|
+ }
|
|
|
+
|
|
|
+ pub fn reference(&self) -> &str {
|
|
|
+ &self.reference
|
|
|
+ }
|
|
|
+
|
|
|
+ pub async fn persist<'a, B, S>(&mut self, storage: &'a S) -> Result<(), Error>
|
|
|
+ where
|
|
|
+ B: Batch<'a>,
|
|
|
+ S: Storage<'a, B> + Sync + Send,
|
|
|
+ {
|
|
|
+ let mut batch = storage.begin().await?;
|
|
|
+ if let Some(status) = batch.get_payment_status(&self.id).await? {
|
|
|
+ if status.is_finalized() {
|
|
|
+ return Err(Error::TransactionUpdatesNotAllowed);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ self.validate()?;
|
|
|
+ batch.store_transaction(self).await?;
|
|
|
+ batch.store_new_payments(&self.create).await?;
|
|
|
+ for input in self.spend.iter_mut() {
|
|
|
+ batch
|
|
|
+ .spend_payment(&input.id, self.status.clone(), &self.id)
|
|
|
+ .await?;
|
|
|
+ }
|
|
|
+ batch.commit().await?;
|
|
|
+ Ok(())
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+impl TryFrom<from_db::Transaction> for Transaction {
|
|
|
+ type Error = Error;
|
|
|
+
|
|
|
+ fn try_from(value: from_db::Transaction) -> Result<Self, Self::Error> {
|
|
|
+ let tx = Transaction {
|
|
|
+ id: value.id,
|
|
|
+ is_external_deposit: value.spend.is_empty(),
|
|
|
+ spend: value.spend,
|
|
|
+ create: value.create,
|
|
|
+ reference: value.reference,
|
|
|
+ status: value.status,
|
|
|
+ };
|
|
|
+ tx.validate()?;
|
|
|
+ Ok(tx)
|
|
|
+ }
|
|
|
+}
|
Cesar Rodas