|
|
@@ -6,7 +6,7 @@ use crate::{
|
|
|
transaction::*,
|
|
|
AccountId, Amount, Asset, PaymentFrom, RevId, Status, TxId,
|
|
|
};
|
|
|
-use chrono::{serde::ts_milliseconds, DateTime, Utc};
|
|
|
+use chrono::{serde::ts_milliseconds, DateTime, TimeZone, Utc};
|
|
|
use serde::{Deserialize, Serialize};
|
|
|
use sha2::{Digest, Sha256};
|
|
|
use std::collections::HashMap;
|
|
|
@@ -21,7 +21,7 @@ use std::collections::HashMap;
|
|
|
///
|
|
|
/// Since the transaction ID is calculated from the transaction itself, to provide cryptographic
|
|
|
/// security that its content was not altered.
|
|
|
-#[derive(Debug, Clone, Deserialize, Serialize)]
|
|
|
+#[derive(Debug, Clone, Deserialize, Serialize, borsh::BorshSerialize, borsh::BorshDeserialize)]
|
|
|
pub struct Revision {
|
|
|
#[serde(rename = "_prev_rev")]
|
|
|
/// Any previous transaction that this transaction is replacing.
|
|
|
@@ -37,26 +37,64 @@ pub struct Revision {
|
|
|
status: Status,
|
|
|
tags: Vec<String>,
|
|
|
#[serde(with = "ts_milliseconds")]
|
|
|
+ #[borsh(
|
|
|
+ serialize_with = "to_ts_microseconds",
|
|
|
+ deserialize_with = "from_ts_microseconds"
|
|
|
+ )]
|
|
|
created_at: DateTime<Utc>,
|
|
|
#[serde(with = "ts_milliseconds")]
|
|
|
+ #[borsh(
|
|
|
+ serialize_with = "to_ts_microseconds",
|
|
|
+ deserialize_with = "from_ts_microseconds"
|
|
|
+ )]
|
|
|
updated_at: DateTime<Utc>,
|
|
|
}
|
|
|
|
|
|
+fn to_ts_microseconds<W: std::io::Write>(
|
|
|
+ dt: &DateTime<Utc>,
|
|
|
+ writer: &mut W,
|
|
|
+) -> std::io::Result<()> {
|
|
|
+ borsh::BorshSerialize::serialize(&dt.timestamp_millis(), writer)?;
|
|
|
+ Ok(())
|
|
|
+}
|
|
|
+
|
|
|
+fn from_ts_microseconds<R: borsh::io::Read>(
|
|
|
+ reader: &mut R,
|
|
|
+) -> ::core::result::Result<DateTime<Utc>, borsh::io::Error> {
|
|
|
+ match Utc.timestamp_millis_opt(borsh::BorshDeserialize::deserialize_reader(reader)?) {
|
|
|
+ chrono::LocalResult::Single(dt) => Ok(dt.with_timezone(&Utc)),
|
|
|
+ _ => Err(borsh::io::Error::new(
|
|
|
+ borsh::io::ErrorKind::InvalidData,
|
|
|
+ "invalid timestamp".to_owned(),
|
|
|
+ )),
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
impl Revision {
|
|
|
/// Calculates a revision ID
|
|
|
pub fn calculate_rev_id(&self) -> Result<RevId, Error> {
|
|
|
let mut hasher = Sha256::new();
|
|
|
- let bytes = bincode::serialize(self)?;
|
|
|
+ let bytes = borsh::to_vec(&self)?;
|
|
|
hasher.update(bytes);
|
|
|
Ok(RevId::new(hasher.finalize().into()))
|
|
|
}
|
|
|
|
|
|
+ /// TODO
|
|
|
+ pub fn to_vec(&self) -> Result<Vec<u8>, crate::storage::Error> {
|
|
|
+ Ok(borsh::to_vec(&self)?)
|
|
|
+ }
|
|
|
+
|
|
|
+ /// TODO
|
|
|
+ pub fn from_slice(slice: &[u8]) -> Result<Self, crate::storage::Error> {
|
|
|
+ Ok(borsh::from_slice(slice)?)
|
|
|
+ }
|
|
|
+
|
|
|
/// The transaction fingerprint is a hash of the properties that are not allowed to be updated
|
|
|
/// in a transaction.
|
|
|
pub fn calculate_id(&self) -> Result<TxId, Error> {
|
|
|
let mut hasher = Sha256::new();
|
|
|
- hasher.update(&bincode::serialize(&self.spends)?);
|
|
|
- hasher.update(&bincode::serialize(&self.creates)?);
|
|
|
+ hasher.update(&borsh::to_vec(&self.spends)?);
|
|
|
+ hasher.update(&borsh::to_vec(&self.creates)?);
|
|
|
hasher.update(&self.typ.to_string());
|
|
|
hasher.update(&self.reference);
|
|
|
hasher.update(&self.created_at.timestamp_millis().to_string());
|
|
|
@@ -173,7 +211,7 @@ pub struct Transaction {
|
|
|
|
|
|
/// The transaction inner details
|
|
|
#[serde(flatten)]
|
|
|
- inner: Revision,
|
|
|
+ revision: Revision,
|
|
|
}
|
|
|
|
|
|
impl Transaction {
|
|
|
@@ -279,18 +317,18 @@ impl Transaction {
|
|
|
id: revision.calculate_id()?,
|
|
|
revision_id,
|
|
|
lastest_revision,
|
|
|
- inner: revision,
|
|
|
+ revision,
|
|
|
})
|
|
|
}
|
|
|
|
|
|
/// Gets the inner transaction
|
|
|
- pub fn inner(&self) -> &Revision {
|
|
|
- &self.inner
|
|
|
+ pub fn revision(&self) -> &Revision {
|
|
|
+ &self.revision
|
|
|
}
|
|
|
|
|
|
/// Returns the previous revision of this transaction, if any
|
|
|
pub fn previous(&self) -> Option<RevId> {
|
|
|
- self.inner.previous.clone()
|
|
|
+ self.revision.previous.clone()
|
|
|
}
|
|
|
|
|
|
/// Returns a unique list of accounts involved in this transaction.
|
|
|
@@ -298,14 +336,14 @@ impl Transaction {
|
|
|
/// Accounts are sorted and unique, and they include the accounts that spent and that receives
|
|
|
pub fn accounts(&self) -> Vec<AccountId> {
|
|
|
let mut accounts = self
|
|
|
- .inner
|
|
|
+ .revision
|
|
|
.creates
|
|
|
.iter()
|
|
|
.map(|x| x.to.clone())
|
|
|
.collect::<Vec<_>>();
|
|
|
|
|
|
accounts.extend(
|
|
|
- self.inner
|
|
|
+ self.revision
|
|
|
.spends
|
|
|
.iter()
|
|
|
.map(|x| x.from.clone())
|
|
|
@@ -335,8 +373,8 @@ impl Transaction {
|
|
|
{
|
|
|
config
|
|
|
.status
|
|
|
- .is_valid_transition(&self.inner.status, &new_status)?;
|
|
|
- let mut inner = self.inner;
|
|
|
+ .is_valid_transition(&self.revision.status, &new_status)?;
|
|
|
+ let mut inner = self.revision;
|
|
|
inner.changelog = reason;
|
|
|
inner.updated_at = Utc::now();
|
|
|
inner.previous = Some(self.revision_id);
|
|
|
@@ -348,24 +386,24 @@ impl Transaction {
|
|
|
|
|
|
/// Validates the transaction before storing
|
|
|
pub(crate) fn validate(&self) -> Result<(), Error> {
|
|
|
- let calculated_revision_id = self.inner.calculate_rev_id()?;
|
|
|
- let calculated_tx_id = self.inner.calculate_id()?;
|
|
|
+ let calculated_revision_id = self.revision.calculate_rev_id()?;
|
|
|
+ let calculated_tx_id = self.revision.calculate_id()?;
|
|
|
|
|
|
if self.revision_id != calculated_revision_id || self.id != calculated_tx_id {
|
|
|
return Err(Error::InvalidTxId(self.id.clone(), calculated_tx_id));
|
|
|
}
|
|
|
|
|
|
- self.inner.validate()
|
|
|
+ self.revision.validate()
|
|
|
}
|
|
|
|
|
|
/// Returns the list of payments that were used to create this transaction
|
|
|
pub fn spends(&self) -> &[PaymentFrom] {
|
|
|
- &self.inner.spends
|
|
|
+ &self.revision.spends
|
|
|
}
|
|
|
|
|
|
/// Returns the list of payments that were created by this transaction
|
|
|
pub fn creates(&self) -> &[PaymentTo] {
|
|
|
- &self.inner.creates
|
|
|
+ &self.revision.creates
|
|
|
}
|
|
|
|
|
|
/// Returns the transaction ID
|
|
|
@@ -375,27 +413,27 @@ impl Transaction {
|
|
|
|
|
|
/// Returns the transaction status
|
|
|
pub fn status(&self) -> &Status {
|
|
|
- &self.inner.status
|
|
|
+ &self.revision.status
|
|
|
}
|
|
|
|
|
|
/// Returns the transaction type
|
|
|
pub fn typ(&self) -> Type {
|
|
|
- self.inner.typ
|
|
|
+ self.revision.typ
|
|
|
}
|
|
|
|
|
|
/// Returns the reference of this transaction
|
|
|
pub fn reference(&self) -> &str {
|
|
|
- &self.inner.reference
|
|
|
+ &self.revision.reference
|
|
|
}
|
|
|
|
|
|
/// Returns the time when this transaction was created
|
|
|
pub fn created_at(&self) -> DateTime<Utc> {
|
|
|
- self.inner.created_at
|
|
|
+ self.revision.created_at
|
|
|
}
|
|
|
|
|
|
/// Returns the time when this transaction was last updated
|
|
|
pub fn updated_at(&self) -> DateTime<Utc> {
|
|
|
- self.inner.updated_at
|
|
|
+ self.revision.updated_at
|
|
|
}
|
|
|
|
|
|
/// Persists the changes done to this transaction object.
|
|
|
@@ -409,63 +447,63 @@ impl Transaction {
|
|
|
|
|
|
let mut batch = config.storage.begin().await?;
|
|
|
|
|
|
- if let Some(previous_id) = &self.inner.previous {
|
|
|
+ if let Some(previous_id) = &self.revision.previous {
|
|
|
// Make sure this update is updating the last revision and the status is not final
|
|
|
let current_transaction = batch.get_and_lock_transaction(&self.id).await?;
|
|
|
|
|
|
- if config.status.is_final(¤t_transaction.inner.status)
|
|
|
- || self.inner.calculate_id()? != current_transaction.inner.calculate_id()?
|
|
|
+ if config.status.is_final(¤t_transaction.revision.status)
|
|
|
+ || self.revision.calculate_id()? != current_transaction.revision.calculate_id()?
|
|
|
|| *previous_id != current_transaction.lastest_revision
|
|
|
{
|
|
|
return Err(Error::TransactionUpdatesNotAllowed);
|
|
|
}
|
|
|
|
|
|
// Updates all the spends to reflect the new status.
|
|
|
- let (updated_created, updated_spent) = if config.status.is_reverted(&self.inner.status)
|
|
|
- {
|
|
|
- // Release all the previously spent payments since the whole transaction is being
|
|
|
- // reverted due a failure or cancellation.
|
|
|
- batch
|
|
|
- .update_transaction_payments(
|
|
|
- &self.id,
|
|
|
- storage::Status::Failed,
|
|
|
- storage::Status::Spendable,
|
|
|
- )
|
|
|
- .await?
|
|
|
- } else if config.status.is_spendable(&self.inner.status) {
|
|
|
- // Spend all the payments that were used to create this transaction
|
|
|
- batch
|
|
|
- .update_transaction_payments(
|
|
|
- &self.id,
|
|
|
- storage::Status::Spendable,
|
|
|
- storage::Status::Spent,
|
|
|
- )
|
|
|
- .await?
|
|
|
- } else {
|
|
|
- // Lock both the spent transaction and the created transaction, since this
|
|
|
- // transaction is still not finalized
|
|
|
- batch
|
|
|
- .update_transaction_payments(
|
|
|
- &self.id,
|
|
|
- storage::Status::Locked,
|
|
|
- storage::Status::Locked,
|
|
|
- )
|
|
|
- .await?
|
|
|
- };
|
|
|
- if updated_created != self.inner.creates.len()
|
|
|
- || updated_spent != self.inner.spends.len()
|
|
|
+ let (updated_created, updated_spent) =
|
|
|
+ if config.status.is_reverted(&self.revision.status) {
|
|
|
+ // Release all the previously spent payments since the whole transaction is
|
|
|
+ // being reverted due a failure or cancellation.
|
|
|
+ batch
|
|
|
+ .update_transaction_payments(
|
|
|
+ &self.id,
|
|
|
+ storage::Status::Failed,
|
|
|
+ storage::Status::Spendable,
|
|
|
+ )
|
|
|
+ .await?
|
|
|
+ } else if config.status.is_spendable(&self.revision.status) {
|
|
|
+ // Spend all the payments that were used to create this transaction
|
|
|
+ batch
|
|
|
+ .update_transaction_payments(
|
|
|
+ &self.id,
|
|
|
+ storage::Status::Spendable,
|
|
|
+ storage::Status::Spent,
|
|
|
+ )
|
|
|
+ .await?
|
|
|
+ } else {
|
|
|
+ // Lock both the spent transaction and the created transaction, since this
|
|
|
+ // transaction is still not finalized
|
|
|
+ batch
|
|
|
+ .update_transaction_payments(
|
|
|
+ &self.id,
|
|
|
+ storage::Status::Locked,
|
|
|
+ storage::Status::Locked,
|
|
|
+ )
|
|
|
+ .await?
|
|
|
+ };
|
|
|
+ if updated_created != self.revision.creates.len()
|
|
|
+ || updated_spent != self.revision.spends.len()
|
|
|
{
|
|
|
return Err(Error::NoUpdate);
|
|
|
}
|
|
|
} else {
|
|
|
let spends = self
|
|
|
- .inner
|
|
|
+ .revision
|
|
|
.spends
|
|
|
.iter()
|
|
|
.map(|x| x.id.clone())
|
|
|
.collect::<Vec<_>>();
|
|
|
let (spent_payment_status, creates_payment_status) =
|
|
|
- if config.status.is_spendable(&self.inner.status) {
|
|
|
+ if config.status.is_spendable(&self.revision.status) {
|
|
|
(storage::Status::Spent, storage::Status::Spendable)
|
|
|
} else {
|
|
|
(storage::Status::Locked, storage::Status::Locked)
|
|
|
@@ -474,7 +512,7 @@ impl Transaction {
|
|
|
.spend_payments(&self.id, spends, spent_payment_status)
|
|
|
.await?;
|
|
|
batch
|
|
|
- .create_payments(&self.id, &self.inner.creates, creates_payment_status)
|
|
|
+ .create_payments(&self.id, &self.revision.creates, creates_payment_status)
|
|
|
.await?;
|
|
|
|
|
|
for account in self.accounts() {
|
